mirror of
https://github.com/rennf93/roboco.git
synced 2026-08-03 07:23:24 +02:00
e97f46af6e
* fix(git): reviewer reads must prefer origin over a diverged local ref _resolve_head_ref (GitService.diff/list_changed_files/read_file_at_branch) kept local priority on ANY divergence from origin, real or rewritten. A reviewer's clone parked on pre-rebase history after the branch's routine force-push sync stayed frozen there across every subsequent review round, while origin held every fix commit — QA repeatedly bounced work that had already landed. Every caller here is a reader, never the branch's own author mid-write, so origin now wins whenever it carries anything the local ref lacks; local keeps priority only when it strictly contains origin (unpushed commits, or equal). The read-only git MCP surface (roboco_git_log) hit the same staleness through a separate path: /api/git/log resolved the requested branch as a bare name straight off whatever the caller's own clone had on disk, with no fetch at all. It now routes through the same fixed _resolve_head_ref. * test(e2e): give the armed flow-verb timeout real headroom The armed value is also verb-2's entire execution budget (claim + every claim guard + set_plan + start + tracing gate), which grows as guards land; 1s flaked on loaded CI runners while passing locally. The cancel-and-release semantics only need the timeout far below the hang. --------- Co-authored-by: Renn F <rennf93@users.noreply.github.com>
1831 lines
72 KiB
Python
1831 lines
72 KiB
Python
"""Unit tests for GitService gateway-backfill methods.
|
|
|
|
These tests target signature-level behavior. Full integration with the
|
|
GitHub REST API + filesystem lives under integration tests; here we
|
|
mock the network and filesystem boundaries.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import asyncio
|
|
from pathlib import Path
|
|
from typing import TYPE_CHECKING
|
|
from unittest.mock import AsyncMock, MagicMock, patch
|
|
from uuid import UUID, uuid4
|
|
|
|
import httpx
|
|
import pytest
|
|
from roboco.config import settings
|
|
from roboco.exceptions import GitCommandError, GitError, MergeConflictError
|
|
from roboco.services.base import NotFoundError, UnauthorizedError, ValidationError
|
|
from roboco.services.forge import RepoRef
|
|
from roboco.services.gateway.quality_gate import GateResult
|
|
from roboco.services.git import GitService
|
|
|
|
if TYPE_CHECKING:
|
|
from contextlib import AbstractContextManager
|
|
|
|
_EXPECTED_PR_NUMBER = 7
|
|
_PUSHED_COMMIT_COUNT = 2
|
|
|
|
|
|
def _make_session(execute_returns: object | None = None) -> MagicMock:
|
|
"""Build a MagicMock-backed session with execute pre-stubbed."""
|
|
session = MagicMock()
|
|
session.execute = AsyncMock(return_value=execute_returns)
|
|
session.commit = AsyncMock()
|
|
session.rollback = AsyncMock()
|
|
session.flush = AsyncMock()
|
|
return session
|
|
|
|
|
|
def _service(execute_returns: object | None = None) -> GitService:
|
|
return GitService(_make_session(execute_returns))
|
|
|
|
|
|
def _patch_project_service(project: object | None) -> AbstractContextManager[object]:
|
|
"""Patch get_project_service to return a service whose .get() resolves project."""
|
|
fake_service = MagicMock()
|
|
fake_service.get = AsyncMock(return_value=project)
|
|
fake_service.get_by_slug = AsyncMock(return_value=project)
|
|
return patch("roboco.services.git.get_project_service", return_value=fake_service)
|
|
|
|
|
|
def _bind(svc: GitService, name: str, value: object) -> None:
|
|
"""Stub `name` on `svc` without tripping mypy's method-assign check.
|
|
|
|
Uses setattr so the attribute lookup is dynamic (vs. attribute
|
|
binding to the class), letting tests override async helpers
|
|
without triggering [method-assign].
|
|
"""
|
|
object.__setattr__(svc, name, value)
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# _task_for_branch + _project_slug_for_branch
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_task_for_branch_returns_task_when_present() -> None:
|
|
fake_task = MagicMock(branch_name="feature/backend/abc12345")
|
|
result = MagicMock()
|
|
result.scalar_one_or_none.return_value = fake_task
|
|
svc = _service(execute_returns=result)
|
|
out = await svc._task_for_branch("feature/backend/abc12345")
|
|
assert out is fake_task
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_task_for_branch_returns_none_when_missing() -> None:
|
|
result = MagicMock()
|
|
result.scalar_one_or_none.return_value = None
|
|
svc = _service(execute_returns=result)
|
|
assert await svc._task_for_branch("nope/branch") is None
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_project_slug_for_branch_returns_slug() -> None:
|
|
project_id = uuid4()
|
|
fake_task = MagicMock(branch_name="feature/backend/x", project_id=project_id)
|
|
fake_project = MagicMock(slug="roboco")
|
|
svc = _service()
|
|
_bind(svc, "_task_for_branch", AsyncMock(return_value=fake_task))
|
|
with _patch_project_service(fake_project):
|
|
out = await svc._project_slug_for_branch("feature/backend/x")
|
|
assert out == "roboco"
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_project_slug_for_branch_none_when_no_task() -> None:
|
|
svc = _service()
|
|
_bind(svc, "_task_for_branch", AsyncMock(return_value=None))
|
|
assert await svc._project_slug_for_branch("missing") is None
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_project_for_task_resolves_coordination_root_via_product() -> None:
|
|
"""A project-less coordination root resolves its repo from the product map."""
|
|
pid = uuid4()
|
|
fake_project = MagicMock(slug="roboco")
|
|
task = MagicMock(project_id=None, product_id=uuid4())
|
|
svc = _service()
|
|
product_svc = MagicMock(distinct_project_ids=AsyncMock(return_value=[pid]))
|
|
with (
|
|
_patch_project_service(fake_project),
|
|
patch("roboco.services.product.get_product_service", return_value=product_svc),
|
|
):
|
|
out = await svc._project_for_task(task)
|
|
assert out is fake_project
|
|
product_svc.distinct_project_ids.assert_awaited_once()
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_project_for_task_uses_project_id_when_present() -> None:
|
|
"""A normal task resolves by project_id exactly as before (additive change)."""
|
|
fake_project = MagicMock(slug="roboco")
|
|
task = MagicMock(project_id=uuid4(), product_id=None)
|
|
svc = _service()
|
|
with _patch_project_service(fake_project):
|
|
out = await svc._project_for_task(task)
|
|
assert out is fake_project
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# push_task_branch: idempotent push at the QA-submission boundary
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_push_task_branch_pushes_task_branch_by_name() -> None:
|
|
"""Pushes the task's branch BY NAME (independent of the current checkout).
|
|
|
|
A dev's clone is shared across many tasks, so by the QA-submission /
|
|
open_pr boundary it is usually parked on a LATER task's branch. The old
|
|
assert-on-current-branch gate rejected the push and the locally-committed
|
|
work never reached origin; the push must target the named ref instead.
|
|
"""
|
|
task = MagicMock(branch_name="feature/backend/abc")
|
|
project = MagicMock(slug="roboco")
|
|
svc = _service()
|
|
_bind(svc, "_assert_task_owned_with_branch", AsyncMock(return_value=task))
|
|
_bind(svc, "_project_for_task", AsyncMock(return_value=project))
|
|
_bind(svc, "get_workspace", AsyncMock(return_value=Path("/tmp/ws")))
|
|
assert_branch = AsyncMock()
|
|
_bind(svc, "_assert_on_task_branch", assert_branch)
|
|
push_mock = AsyncMock(return_value=("feature/backend/abc", _PUSHED_COMMIT_COUNT))
|
|
_bind(svc, "push", push_mock)
|
|
|
|
pushed = await svc.push_task_branch(uuid4(), uuid4())
|
|
|
|
assert pushed == _PUSHED_COMMIT_COUNT
|
|
push_mock.assert_awaited_once_with(Path("/tmp/ws"), branch="feature/backend/abc")
|
|
# The old current-branch gate is no longer consulted on the push path.
|
|
assert_branch.assert_not_awaited()
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_push_task_branch_runs_codegen_before_push() -> None:
|
|
"""push_task_branch regenerates + commits codegen drift before pushing."""
|
|
task = MagicMock(branch_name="feature/backend/abc")
|
|
project = MagicMock(slug="roboco")
|
|
svc = _service()
|
|
_bind(svc, "_assert_task_owned_with_branch", AsyncMock(return_value=task))
|
|
_bind(svc, "_project_for_task", AsyncMock(return_value=project))
|
|
_bind(svc, "get_workspace", AsyncMock(return_value=Path("/tmp/ws")))
|
|
codegen_mock = AsyncMock()
|
|
_bind(svc, "_run_codegen_and_commit", codegen_mock)
|
|
push_mock = AsyncMock(return_value=("feature/backend/abc", _PUSHED_COMMIT_COUNT))
|
|
_bind(svc, "push", push_mock)
|
|
|
|
agent_id = uuid4()
|
|
await svc.push_task_branch(agent_id, uuid4())
|
|
|
|
codegen_mock.assert_awaited_once_with(
|
|
"feature/backend/abc", Path("/tmp/ws"), actor_agent_id=agent_id
|
|
)
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_push_branch_pushes_named_branch_not_current_checkout() -> None:
|
|
"""push_branch (open_pr's push side effect) pushes the NAMED branch.
|
|
|
|
The clone root is shared across a dev's tasks and (F123) parked on the
|
|
default branch while the task branch lives in a per-task worktree.
|
|
push_branch used to call push(workspace) with no ``branch`` arg, so
|
|
push() fell back to get_current_branch(workspace) and pushed the wrong
|
|
ref (the clone root's checkout, e.g. the default branch). The dev's
|
|
commit then never reached origin, create_pr 422'd with "No commits
|
|
between", and the dev was forced into i_am_blocked — stranded work the
|
|
PM's unblock cannot repair (it flips status, not git state). The named
|
|
branch must be passed through to push().
|
|
"""
|
|
branch_name = "feature/backend/fb836f80--03f80432--d3dab0fc--b04afcb5"
|
|
svc = _service()
|
|
_bind(svc, "_workspace_for_branch", AsyncMock(return_value=Path("/tmp/ws")))
|
|
push_mock = AsyncMock(return_value=(branch_name, _PUSHED_COMMIT_COUNT))
|
|
_bind(svc, "push", push_mock)
|
|
|
|
result_branch, pushed = await svc.push_branch(branch_name)
|
|
|
|
assert result_branch == branch_name
|
|
assert pushed == _PUSHED_COMMIT_COUNT
|
|
# The named branch is forwarded to push() — NOT push(workspace) which
|
|
# would default to the clone root's current checkout.
|
|
push_mock.assert_awaited_once_with(Path("/tmp/ws"), branch=branch_name)
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_push_branch_runs_codegen_before_push() -> None:
|
|
"""push_branch (open_pr's FIRST push) regenerates + commits codegen drift
|
|
before pushing — the initial PR head must never carry stale artifacts."""
|
|
branch_name = "feature/backend/abc"
|
|
svc = _service()
|
|
_bind(svc, "_workspace_for_branch", AsyncMock(return_value=Path("/tmp/ws")))
|
|
codegen_mock = AsyncMock()
|
|
_bind(svc, "_run_codegen_and_commit", codegen_mock)
|
|
push_mock = AsyncMock(return_value=(branch_name, _PUSHED_COMMIT_COUNT))
|
|
_bind(svc, "push", push_mock)
|
|
|
|
actor_id = uuid4()
|
|
await svc.push_branch(branch_name, actor_agent_id=actor_id)
|
|
|
|
codegen_mock.assert_awaited_once_with(
|
|
branch_name, Path("/tmp/ws"), actor_agent_id=actor_id
|
|
)
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_push_targets_explicit_branch_not_current_checkout() -> None:
|
|
"""push(branch=X) pushes X by ref even when the workspace is on Y."""
|
|
svc = _service()
|
|
_bind(svc, "get_current_branch", AsyncMock(return_value="feature/frontend/OTHER"))
|
|
_bind(svc, "_token_for_workspace", AsyncMock(return_value=None))
|
|
calls: list[list[str]] = []
|
|
|
|
async def _run_git(_ws: object, args: list[str], **_kw: object) -> MagicMock:
|
|
calls.append(args)
|
|
res = MagicMock()
|
|
res.returncode = 0
|
|
res.stdout = "3" if args[:2] == ["rev-list", "--count"] else ""
|
|
return res
|
|
|
|
_bind(svc, "_run_git", AsyncMock(side_effect=_run_git))
|
|
|
|
branch, _pushed = await svc.push(Path("/tmp/ws"), branch="feature/frontend/TASK")
|
|
|
|
assert branch == "feature/frontend/TASK"
|
|
push_args = next(a for a in calls if a and a[0] == "push")
|
|
assert "feature/frontend/TASK" in push_args
|
|
assert "feature/frontend/OTHER" not in push_args
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_push_recovers_missing_local_branch_from_origin() -> None:
|
|
"""A push-by-name on a re-provisioned/shared clone missing the local ref
|
|
recovers it from origin instead of dying on "src refspec ... does not
|
|
match any".
|
|
|
|
The branch's commits are already on origin (pushed in a prior cycle/clone),
|
|
so after recreating the local tracking ref the push is a clean no-op.
|
|
"""
|
|
svc = _service()
|
|
_bind(svc, "_token_for_workspace", AsyncMock(return_value=None))
|
|
calls: list[list[str]] = []
|
|
|
|
async def _run_git(_ws: object, args: list[str], **_kw: object) -> MagicMock:
|
|
calls.append(args)
|
|
res = MagicMock()
|
|
# Local ref MISSING; origin HAS it.
|
|
if args[:2] == ["rev-parse", "--verify"]:
|
|
is_local = any(a.startswith("refs/heads/") for a in args)
|
|
res.returncode = 1 if is_local else 0
|
|
res.stdout = ""
|
|
return res
|
|
res.returncode = 0
|
|
res.stdout = "0" if args[:2] == ["rev-list", "--count"] else ""
|
|
return res
|
|
|
|
_bind(svc, "_run_git", AsyncMock(side_effect=_run_git))
|
|
|
|
branch, _pushed = await svc.push(Path("/tmp/ws"), branch="feature/backend/TASK")
|
|
|
|
assert branch == "feature/backend/TASK"
|
|
# It fetched origin and recreated the local ref before pushing.
|
|
assert ["fetch", "origin", "feature/backend/TASK"] in calls
|
|
assert ["branch", "feature/backend/TASK", "origin/feature/backend/TASK"] in calls
|
|
assert any(a and a[0] == "push" for a in calls)
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_push_fails_loud_when_branch_absent_local_and_origin() -> None:
|
|
"""When the named branch is in neither the local clone nor origin, the work
|
|
is genuinely lost from this clone — fail with a recoverable instruction, not
|
|
the raw "src refspec does not match any"."""
|
|
svc = _service()
|
|
_bind(svc, "_token_for_workspace", AsyncMock(return_value=None))
|
|
|
|
async def _run_git(_ws: object, args: list[str], **_kw: object) -> MagicMock:
|
|
res = MagicMock()
|
|
if args[:2] == ["rev-parse", "--verify"]:
|
|
res.returncode = 1 # absent both locally and on origin
|
|
res.stdout = ""
|
|
return res
|
|
res.returncode = 0
|
|
res.stdout = ""
|
|
return res
|
|
|
|
_bind(svc, "_run_git", AsyncMock(side_effect=_run_git))
|
|
|
|
with pytest.raises(GitCommandError, match="unclaim the task and"):
|
|
await svc.push(Path("/tmp/ws"), branch="feature/backend/GONE")
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_push_force_uses_force_with_lease_not_bare_force() -> None:
|
|
"""push(force=True) must use --force-with-lease, not bare --force.
|
|
|
|
Bare --force silently overwrites a concurrent remote advance; --force-with-lease
|
|
fails fast instead of clobbering someone else's commits.
|
|
"""
|
|
svc = _service()
|
|
_bind(svc, "_token_for_workspace", AsyncMock(return_value=None))
|
|
calls: list[list[str]] = []
|
|
|
|
async def _run_git(_ws: object, args: list[str], **_kw: object) -> MagicMock:
|
|
calls.append(args)
|
|
res = MagicMock()
|
|
res.returncode = 0
|
|
res.stdout = "0" if args[:2] == ["rev-list", "--count"] else ""
|
|
return res
|
|
|
|
_bind(svc, "_run_git", AsyncMock(side_effect=_run_git))
|
|
|
|
await svc.push(Path("/tmp/ws"), force=True, branch="feature/backend/TASK")
|
|
|
|
push_args = next(a for a in calls if a and a[0] == "push")
|
|
assert "--force-with-lease" in push_args
|
|
assert "--force" not in push_args
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_push_no_force_has_neither_flag() -> None:
|
|
"""push(force=False) carries neither --force nor --force-with-lease."""
|
|
svc = _service()
|
|
_bind(svc, "_token_for_workspace", AsyncMock(return_value=None))
|
|
calls: list[list[str]] = []
|
|
|
|
async def _run_git(_ws: object, args: list[str], **_kw: object) -> MagicMock:
|
|
calls.append(args)
|
|
res = MagicMock()
|
|
res.returncode = 0
|
|
res.stdout = "0" if args[:2] == ["rev-list", "--count"] else ""
|
|
return res
|
|
|
|
_bind(svc, "_run_git", AsyncMock(side_effect=_run_git))
|
|
|
|
await svc.push(Path("/tmp/ws"), force=False, branch="feature/backend/TASK")
|
|
|
|
push_args = next(a for a in calls if a and a[0] == "push")
|
|
assert "--force-with-lease" not in push_args
|
|
assert "--force" not in push_args
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_pr_head_is_task_branch_not_current() -> None:
|
|
"""The PR head is the task's recorded branch, not the workspace checkout."""
|
|
task = MagicMock(branch_name="feature/frontend/TASK")
|
|
svc = _service()
|
|
_bind(svc, "get_current_branch", AsyncMock(return_value="feature/frontend/OTHER"))
|
|
req = MagicMock(task_id=uuid4())
|
|
with patch("roboco.services.git.get_task_service") as gts:
|
|
gts.return_value.get = AsyncMock(return_value=task)
|
|
head = await svc._pr_head_branch(Path("/tmp/ws"), req)
|
|
assert head == "feature/frontend/TASK"
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_pr_head_falls_back_to_current_when_no_task() -> None:
|
|
"""No task_id → the PR head is the current checkout (unchanged behavior)."""
|
|
svc = _service()
|
|
_bind(svc, "get_current_branch", AsyncMock(return_value="feature/frontend/CUR"))
|
|
req = MagicMock(task_id=None)
|
|
head = await svc._pr_head_branch(Path("/tmp/ws"), req)
|
|
assert head == "feature/frontend/CUR"
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_push_task_branch_noop_for_project_less_task() -> None:
|
|
"""A git-exempt task (no resolvable project) is a no-op, not an error."""
|
|
task = MagicMock(branch_name="feature/main_pm/abc")
|
|
svc = _service()
|
|
_bind(svc, "_assert_task_owned_with_branch", AsyncMock(return_value=task))
|
|
_bind(svc, "_project_for_task", AsyncMock(return_value=None))
|
|
push_mock = AsyncMock()
|
|
_bind(svc, "push", push_mock)
|
|
|
|
pushed = await svc.push_task_branch(uuid4(), uuid4())
|
|
|
|
assert pushed == 0
|
|
push_mock.assert_not_awaited()
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# _run_codegen_and_commit: regenerate + commit codegen drift before push
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
def test_codegen_command_for_returns_none_when_unset() -> None:
|
|
project = MagicMock(codegen_command=None)
|
|
assert GitService._codegen_command_for(project) is None
|
|
|
|
|
|
def test_codegen_command_for_ignores_unspecced_mock_attribute() -> None:
|
|
"""A bare MagicMock auto-vivifies codegen_command as a truthy MagicMock —
|
|
the isinstance(str) guard must treat that the same as unset, or every
|
|
loosely-specced GitService test would spuriously trip the codegen path."""
|
|
assert GitService._codegen_command_for(MagicMock()) is None
|
|
|
|
|
|
def test_codegen_command_for_returns_configured_command() -> None:
|
|
project = MagicMock(codegen_command="make codegen")
|
|
assert GitService._codegen_command_for(project) == "make codegen"
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_run_codegen_and_commit_noop_when_command_unset() -> None:
|
|
"""Null codegen_command (most projects) never runs a subprocess."""
|
|
task = MagicMock(id=uuid4(), branch_name="feature/backend/abc")
|
|
project = MagicMock(codegen_command=None)
|
|
svc = _service()
|
|
_bind(svc, "_task_for_branch", AsyncMock(return_value=task))
|
|
_bind(svc, "_project_for_task", AsyncMock(return_value=project))
|
|
run_mock = AsyncMock()
|
|
with patch("roboco.services.git.run_quality_commands", run_mock):
|
|
await svc._run_codegen_and_commit("feature/backend/abc", Path("/tmp/ws"))
|
|
run_mock.assert_not_awaited()
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_run_codegen_and_commit_noop_when_no_task() -> None:
|
|
svc = _service()
|
|
_bind(svc, "_task_for_branch", AsyncMock(return_value=None))
|
|
run_mock = AsyncMock()
|
|
with patch("roboco.services.git.run_quality_commands", run_mock):
|
|
await svc._run_codegen_and_commit("feature/backend/missing", Path("/tmp/ws"))
|
|
run_mock.assert_not_awaited()
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_run_codegen_and_commit_commits_drift() -> None:
|
|
"""Codegen runs clean but produces NEW drift -> scoped `git add --` (not
|
|
`-A`) + a task-prefixed commit, and the commit is linked to the task."""
|
|
task_id = uuid4()
|
|
agent_id = uuid4()
|
|
task = MagicMock(id=task_id, branch_name="feature/backend/abc", assigned_to=None)
|
|
project = MagicMock(codegen_command="make codegen", slug="roboco")
|
|
svc = _service()
|
|
_bind(svc, "_task_for_branch", AsyncMock(return_value=task))
|
|
_bind(svc, "_project_for_task", AsyncMock(return_value=project))
|
|
_bind(svc, "_ensure_worktree_for_commit", AsyncMock())
|
|
link_mock = AsyncMock()
|
|
_bind(svc, "_link_commit_to_task", link_mock)
|
|
calls: list[list[str]] = []
|
|
status_calls = 0
|
|
|
|
async def _run_git(_ws: object, args: list[str], **_kw: object) -> MagicMock:
|
|
nonlocal status_calls
|
|
calls.append(args)
|
|
res = MagicMock()
|
|
res.returncode = 0
|
|
if args == ["status", "--porcelain"]:
|
|
status_calls += 1
|
|
# Clean before codegen runs; codegen dirties one new path.
|
|
res.stdout = "" if status_calls == 1 else " M docs/rag/lifecycle/foo.md\n"
|
|
elif args[0] == "rev-parse":
|
|
res.stdout = "abc123deadbeef\n"
|
|
else:
|
|
res.stdout = ""
|
|
return res
|
|
|
|
_bind(svc, "_run_git", AsyncMock(side_effect=_run_git))
|
|
gate_result = GateResult(passed=True, output="ok")
|
|
with patch(
|
|
"roboco.services.git.run_quality_commands",
|
|
AsyncMock(return_value=gate_result),
|
|
):
|
|
await svc._run_codegen_and_commit(
|
|
"feature/backend/abc", Path("/tmp/ws"), actor_agent_id=agent_id
|
|
)
|
|
|
|
assert ["add", "--", "docs/rag/lifecycle/foo.md"] in calls
|
|
assert not any(c[:2] == ["add", "-A"] for c in calls)
|
|
expected_message = f"[{str(task_id)[:8]}] regenerate generated artifacts"
|
|
commit_call = next(c for c in calls if c[0] == "commit")
|
|
assert commit_call == ["commit", "-m", expected_message]
|
|
link_mock.assert_awaited_once_with(
|
|
task_id, "abc123deadbeef", expected_message, agent_id
|
|
)
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_run_codegen_and_commit_excludes_pre_existing_dirty_file() -> None:
|
|
"""A file already dirty before codegen ran (e.g. crash-orphaned edits the
|
|
resume no-op left behind) must never be swept into the auto-commit, even
|
|
though codegen also touches it — only genuinely NEW drift is staged."""
|
|
task_id = uuid4()
|
|
task = MagicMock(id=task_id, branch_name="feature/backend/abc", assigned_to=None)
|
|
project = MagicMock(codegen_command="make codegen", slug="roboco")
|
|
svc = _service()
|
|
_bind(svc, "_task_for_branch", AsyncMock(return_value=task))
|
|
_bind(svc, "_project_for_task", AsyncMock(return_value=project))
|
|
_bind(svc, "_ensure_worktree_for_commit", AsyncMock())
|
|
_bind(svc, "_link_commit_to_task", AsyncMock())
|
|
calls: list[list[str]] = []
|
|
status_calls = 0
|
|
|
|
async def _run_git(_ws: object, args: list[str], **_kw: object) -> MagicMock:
|
|
nonlocal status_calls
|
|
calls.append(args)
|
|
res = MagicMock()
|
|
res.returncode = 0
|
|
if args == ["status", "--porcelain"]:
|
|
status_calls += 1
|
|
res.stdout = (
|
|
" M crash_orphaned.txt\n"
|
|
if status_calls == 1
|
|
else " M crash_orphaned.txt\n M docs/rag/lifecycle/foo.md\n"
|
|
)
|
|
elif args[0] == "rev-parse":
|
|
res.stdout = "deadbeef\n"
|
|
else:
|
|
res.stdout = ""
|
|
return res
|
|
|
|
_bind(svc, "_run_git", AsyncMock(side_effect=_run_git))
|
|
gate_result = GateResult(passed=True, output="ok")
|
|
with patch(
|
|
"roboco.services.git.run_quality_commands",
|
|
AsyncMock(return_value=gate_result),
|
|
):
|
|
await svc._run_codegen_and_commit("feature/backend/abc", Path("/tmp/ws"))
|
|
|
|
add_call = next(c for c in calls if c[0] == "add")
|
|
assert add_call == ["add", "--", "docs/rag/lifecycle/foo.md"]
|
|
assert "crash_orphaned.txt" not in add_call
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_run_codegen_and_commit_noop_when_no_new_drift() -> None:
|
|
"""Codegen only touches what was already dirty pre-run -> the newly-dirty
|
|
set is empty, so nothing is staged or committed even though the worktree
|
|
is dirty both before and after."""
|
|
task = MagicMock(id=uuid4(), branch_name="feature/backend/abc")
|
|
project = MagicMock(codegen_command="make codegen", slug="roboco")
|
|
svc = _service()
|
|
_bind(svc, "_task_for_branch", AsyncMock(return_value=task))
|
|
_bind(svc, "_project_for_task", AsyncMock(return_value=project))
|
|
_bind(svc, "_ensure_worktree_for_commit", AsyncMock())
|
|
calls: list[list[str]] = []
|
|
|
|
async def _run_git(_ws: object, args: list[str], **_kw: object) -> MagicMock:
|
|
calls.append(args)
|
|
res = MagicMock()
|
|
res.returncode = 0
|
|
res.stdout = " M pre_existing.txt\n" if args[0] == "status" else ""
|
|
return res
|
|
|
|
_bind(svc, "_run_git", AsyncMock(side_effect=_run_git))
|
|
gate_result = GateResult(passed=True, output="ok")
|
|
with patch(
|
|
"roboco.services.git.run_quality_commands",
|
|
AsyncMock(return_value=gate_result),
|
|
):
|
|
await svc._run_codegen_and_commit("feature/backend/abc", Path("/tmp/ws"))
|
|
|
|
assert not any(c[0] in ("add", "commit") for c in calls)
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_run_codegen_and_commit_noop_when_codegen_clean() -> None:
|
|
"""Codegen runs clean with NO drift -> git status is clean, no commit."""
|
|
task = MagicMock(id=uuid4(), branch_name="feature/backend/abc")
|
|
project = MagicMock(codegen_command="make codegen", slug="roboco")
|
|
svc = _service()
|
|
_bind(svc, "_task_for_branch", AsyncMock(return_value=task))
|
|
_bind(svc, "_project_for_task", AsyncMock(return_value=project))
|
|
_bind(svc, "_ensure_worktree_for_commit", AsyncMock())
|
|
calls: list[list[str]] = []
|
|
|
|
async def _run_git(_ws: object, args: list[str], **_kw: object) -> MagicMock:
|
|
calls.append(args)
|
|
res = MagicMock()
|
|
res.returncode = 0
|
|
res.stdout = ""
|
|
return res
|
|
|
|
_bind(svc, "_run_git", AsyncMock(side_effect=_run_git))
|
|
gate_result = GateResult(passed=True, output="ok")
|
|
with patch(
|
|
"roboco.services.git.run_quality_commands",
|
|
AsyncMock(return_value=gate_result),
|
|
):
|
|
await svc._run_codegen_and_commit("feature/backend/abc", Path("/tmp/ws"))
|
|
|
|
assert not any(c[0] in ("add", "commit") for c in calls)
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_run_codegen_and_commit_fail_open_on_command_failure() -> None:
|
|
"""A non-zero codegen exit logs a warning and skips the commit (fail-open) —
|
|
push must proceed rather than a broken codegen command blocking delivery."""
|
|
task = MagicMock(id=uuid4(), branch_name="feature/backend/abc")
|
|
project = MagicMock(codegen_command="make codegen", slug="roboco")
|
|
svc = _service()
|
|
_bind(svc, "_task_for_branch", AsyncMock(return_value=task))
|
|
_bind(svc, "_project_for_task", AsyncMock(return_value=project))
|
|
_bind(svc, "_ensure_worktree_for_commit", AsyncMock())
|
|
calls: list[list[str]] = []
|
|
|
|
async def _run_git(_ws: object, args: list[str], **_kw: object) -> MagicMock:
|
|
calls.append(args)
|
|
res = MagicMock()
|
|
res.returncode = 0
|
|
res.stdout = ""
|
|
return res
|
|
|
|
_bind(svc, "_run_git", AsyncMock(side_effect=_run_git))
|
|
gate_result = GateResult(passed=False, failures=("codegen",), output="boom")
|
|
with patch(
|
|
"roboco.services.git.run_quality_commands",
|
|
AsyncMock(return_value=gate_result),
|
|
):
|
|
await svc._run_codegen_and_commit("feature/backend/abc", Path("/tmp/ws"))
|
|
|
|
# Only the pre-codegen baseline status is read (needed for the eventual
|
|
# diff); a failed codegen command skips the post-run status, add, and
|
|
# commit entirely.
|
|
assert calls == [["status", "--porcelain"]]
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_run_codegen_and_commit_links_commit_to_task() -> None:
|
|
"""The auto-commit is linked to the task/work-session the same way every
|
|
other commit path is (`_link_commit_to_task`), using the resolved HEAD
|
|
sha and the threaded-through actor agent id."""
|
|
task_id = uuid4()
|
|
agent_id = uuid4()
|
|
task = MagicMock(id=task_id, branch_name="feature/backend/abc", assigned_to=None)
|
|
project = MagicMock(codegen_command="make codegen", slug="roboco")
|
|
svc = _service()
|
|
_bind(svc, "_task_for_branch", AsyncMock(return_value=task))
|
|
_bind(svc, "_project_for_task", AsyncMock(return_value=project))
|
|
_bind(svc, "_ensure_worktree_for_commit", AsyncMock())
|
|
link_mock = AsyncMock()
|
|
_bind(svc, "_link_commit_to_task", link_mock)
|
|
status_calls = 0
|
|
|
|
async def _run_git(_ws: object, args: list[str], **_kw: object) -> MagicMock:
|
|
nonlocal status_calls
|
|
res = MagicMock()
|
|
res.returncode = 0
|
|
if args == ["status", "--porcelain"]:
|
|
status_calls += 1
|
|
res.stdout = "" if status_calls == 1 else " M docs/rag/lifecycle/foo.md\n"
|
|
elif args[0] == "rev-parse":
|
|
res.stdout = "cafebabe1234\n"
|
|
else:
|
|
res.stdout = ""
|
|
return res
|
|
|
|
_bind(svc, "_run_git", AsyncMock(side_effect=_run_git))
|
|
gate_result = GateResult(passed=True, output="ok")
|
|
with patch(
|
|
"roboco.services.git.run_quality_commands",
|
|
AsyncMock(return_value=gate_result),
|
|
):
|
|
await svc._run_codegen_and_commit(
|
|
"feature/backend/abc", Path("/tmp/ws"), actor_agent_id=agent_id
|
|
)
|
|
|
|
expected_message = f"[{str(task_id)[:8]}] regenerate generated artifacts"
|
|
link_mock.assert_awaited_once_with(
|
|
task_id, "cafebabe1234", expected_message, agent_id
|
|
)
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_run_codegen_and_commit_fail_open_on_exception() -> None:
|
|
"""Any unexpected exception (worktree resolution, git failure, ...) must
|
|
never raise out of this helper and break the caller's push."""
|
|
svc = _service()
|
|
_bind(svc, "_task_for_branch", AsyncMock(side_effect=RuntimeError("boom")))
|
|
await svc._run_codegen_and_commit("feature/backend/abc", Path("/tmp/ws"))
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# diff: derives parent + invokes git diff
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_diff_returns_diff_stdout() -> None:
|
|
svc = _service()
|
|
_bind(svc, "_workspace_for_branch", AsyncMock(return_value=Path("/tmp/ws")))
|
|
|
|
async def _run_git(
|
|
_workspace: Path,
|
|
args: list[str],
|
|
check: bool = True,
|
|
token: str | None = None,
|
|
) -> MagicMock:
|
|
del check, token
|
|
if args[:1] == ["fetch"]:
|
|
return MagicMock(stdout="", returncode=0)
|
|
if args[:1] == ["rev-parse"]:
|
|
return MagicMock(stdout="", returncode=0)
|
|
if args[:1] == ["rev-list"]:
|
|
return MagicMock(stdout="0", returncode=0)
|
|
return MagicMock(stdout="diff --git a b\n+hello\n", returncode=0)
|
|
|
|
_bind(svc, "_run_git", AsyncMock(side_effect=_run_git))
|
|
out = await svc.diff(branch_name="feature/backend/abc")
|
|
assert "+hello" in out
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_read_file_at_branch_returns_committed_content() -> None:
|
|
svc = _service()
|
|
_bind(svc, "_workspace_for_branch", AsyncMock(return_value=Path("/tmp/ws")))
|
|
_bind(svc, "_token_for_branch", AsyncMock(return_value=None))
|
|
_bind(svc, "_resolve_head_ref", AsyncMock(return_value="HEAD"))
|
|
_bind(
|
|
svc,
|
|
"_run_git",
|
|
AsyncMock(return_value=MagicMock(stdout="# API\nbody\n", returncode=0)),
|
|
)
|
|
out = await svc.read_file_at_branch(
|
|
branch_name="feature/backend/abc", path="docs/api.md"
|
|
)
|
|
assert out == "# API\nbody\n"
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_read_file_at_branch_missing_returns_none() -> None:
|
|
svc = _service()
|
|
_bind(svc, "_workspace_for_branch", AsyncMock(return_value=Path("/tmp/ws")))
|
|
_bind(svc, "_token_for_branch", AsyncMock(return_value=None))
|
|
_bind(svc, "_resolve_head_ref", AsyncMock(return_value="HEAD"))
|
|
# git show on a path that isn't in the tree exits non-zero.
|
|
_bind(
|
|
svc,
|
|
"_run_git",
|
|
AsyncMock(return_value=MagicMock(stdout="", returncode=128)),
|
|
)
|
|
out = await svc.read_file_at_branch(
|
|
branch_name="feature/backend/abc", path="nope.md"
|
|
)
|
|
assert out is None
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# pr_target: GitHub round-trip
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_pr_target_returns_base_ref() -> None:
|
|
project_id = uuid4()
|
|
fake_task = MagicMock(project_id=project_id, assigned_to=uuid4())
|
|
fake_project = MagicMock(slug="roboco")
|
|
result = MagicMock()
|
|
result.scalar_one_or_none.return_value = fake_task
|
|
|
|
svc = _service(execute_returns=result)
|
|
_bind(svc, "get_workspace", AsyncMock(return_value=Path("/tmp/ws")))
|
|
_bind(svc, "_parse_github_remote", MagicMock(return_value=RepoRef("acme", "repo")))
|
|
_bind(svc, "_get_project_token_or_raise", AsyncMock(return_value="token"))
|
|
|
|
fake_response = MagicMock()
|
|
fake_response.is_success = True
|
|
fake_response.json.return_value = {"base": {"ref": "feature/parent"}}
|
|
fake_client = MagicMock()
|
|
fake_client.__aenter__ = AsyncMock(return_value=fake_client)
|
|
fake_client.__aexit__ = AsyncMock(return_value=False)
|
|
fake_client.get = AsyncMock(return_value=fake_response)
|
|
|
|
with (
|
|
_patch_project_service(fake_project),
|
|
patch("roboco.services.git.httpx.AsyncClient", return_value=fake_client),
|
|
):
|
|
out = await svc.pr_target(42, project_id=project_id)
|
|
assert out == "feature/parent"
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_pr_target_raises_when_pr_not_found() -> None:
|
|
result = MagicMock()
|
|
result.scalar_one_or_none.return_value = None
|
|
svc = _service(execute_returns=result)
|
|
with pytest.raises(NotFoundError):
|
|
await svc.pr_target(99, project_id=uuid4())
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# create_pr: parses response and stores PR
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_create_pr_returns_pr_dict() -> None:
|
|
project_id = uuid4()
|
|
fake_task = MagicMock(
|
|
id=uuid4(),
|
|
project_id=project_id,
|
|
assigned_to=uuid4(),
|
|
title="Add login",
|
|
description="A short description",
|
|
)
|
|
fake_project = MagicMock(slug="roboco")
|
|
svc = _service()
|
|
_bind(svc, "_task_for_branch", AsyncMock(return_value=fake_task))
|
|
_bind(svc, "_workspace_for_branch", AsyncMock(return_value=Path("/tmp/ws")))
|
|
_bind(svc, "_get_project_token_or_raise", AsyncMock(return_value="tok"))
|
|
_bind(svc, "_parse_github_remote", MagicMock(return_value=RepoRef("acme", "repo")))
|
|
_bind(svc, "_record_pr_atomically", AsyncMock())
|
|
# parent == default → _ensure_base_on_remote short-circuits (no git call)
|
|
_bind(svc, "_project_default_branch", AsyncMock(return_value="master"))
|
|
|
|
fake_resp = MagicMock()
|
|
fake_resp.is_success = True
|
|
fake_resp.status_code = 201
|
|
fake_resp.json.return_value = {
|
|
"number": _EXPECTED_PR_NUMBER,
|
|
"html_url": f"https://github.com/acme/repo/pull/{_EXPECTED_PR_NUMBER}",
|
|
}
|
|
_bind(svc, "_post_pr", AsyncMock(return_value=fake_resp))
|
|
_bind(svc, "_apply_pr_labels", AsyncMock())
|
|
|
|
with _patch_project_service(fake_project):
|
|
out = await svc.create_pr(
|
|
"feature/backend/abc12345", parent="master", is_root_pr=True
|
|
)
|
|
assert out["pr_number"] == _EXPECTED_PR_NUMBER
|
|
assert "github.com" in out["pr_url"]
|
|
assert out["is_root_pr"] is True
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_create_pr_records_pr_despite_cancellation_after_post() -> None:
|
|
"""A cancellation landing after the GitHub POST succeeds but before the
|
|
local record commits must not lose the record: asyncio.shield lets
|
|
_record_pr_atomically finish, the cancellation still propagates."""
|
|
project_id = uuid4()
|
|
fake_task = MagicMock(
|
|
id=uuid4(),
|
|
project_id=project_id,
|
|
assigned_to=uuid4(),
|
|
title="Add login",
|
|
description="A short description",
|
|
)
|
|
fake_project = MagicMock(slug="roboco")
|
|
svc = _service()
|
|
_bind(svc, "_task_for_branch", AsyncMock(return_value=fake_task))
|
|
_bind(svc, "_workspace_for_branch", AsyncMock(return_value=Path("/tmp/ws")))
|
|
_bind(svc, "_get_project_token_or_raise", AsyncMock(return_value="tok"))
|
|
_bind(svc, "_parse_github_remote", MagicMock(return_value=RepoRef("acme", "repo")))
|
|
_bind(svc, "_project_default_branch", AsyncMock(return_value="master"))
|
|
|
|
recorded = {"done": False}
|
|
|
|
async def _slow_record(*_args: object, **_kwargs: object) -> None:
|
|
await asyncio.sleep(0.05)
|
|
recorded["done"] = True
|
|
|
|
_bind(svc, "_record_pr_atomically", _slow_record)
|
|
|
|
fake_resp = MagicMock()
|
|
fake_resp.is_success = True
|
|
fake_resp.status_code = 201
|
|
fake_resp.json.return_value = {
|
|
"number": _EXPECTED_PR_NUMBER,
|
|
"html_url": f"https://github.com/acme/repo/pull/{_EXPECTED_PR_NUMBER}",
|
|
}
|
|
_bind(svc, "_post_pr", AsyncMock(return_value=fake_resp))
|
|
_bind(svc, "_apply_pr_labels", AsyncMock())
|
|
|
|
with _patch_project_service(fake_project):
|
|
task = asyncio.ensure_future(
|
|
svc.create_pr("feature/backend/abc12345", parent="master", is_root_pr=True)
|
|
)
|
|
await asyncio.sleep(0.01) # let create_pr reach the shielded await
|
|
task.cancel()
|
|
with pytest.raises(asyncio.CancelledError):
|
|
await task
|
|
|
|
# _await_shielded waits the in-flight record out BEFORE re-raising, so
|
|
# by the time `await task` raised, the record had already completed.
|
|
assert recorded["done"] is True, (
|
|
"shield must let the record finish despite cancellation"
|
|
)
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_create_pr_cancellation_waits_out_record_before_reraising() -> None:
|
|
"""Ordering guard for _await_shielded: on cancellation the in-flight
|
|
_record_pr_atomically must run to COMPLETION before CancelledError
|
|
re-raises to the caller. A bare asyncio.shield detaches the write and
|
|
re-raises immediately — the write then races get_db's rollback on the
|
|
same AsyncSession and asyncpg raises InterfaceError ('another operation
|
|
is in progress'), escaping as a 500 instead of the middleware's 504."""
|
|
project_id = uuid4()
|
|
fake_task = MagicMock(
|
|
id=uuid4(),
|
|
project_id=project_id,
|
|
assigned_to=uuid4(),
|
|
title="Add login",
|
|
description="A short description",
|
|
)
|
|
fake_project = MagicMock(slug="roboco")
|
|
svc = _service()
|
|
_bind(svc, "_task_for_branch", AsyncMock(return_value=fake_task))
|
|
_bind(svc, "_workspace_for_branch", AsyncMock(return_value=Path("/tmp/ws")))
|
|
_bind(svc, "_get_project_token_or_raise", AsyncMock(return_value="tok"))
|
|
_bind(svc, "_parse_github_remote", MagicMock(return_value=RepoRef("acme", "repo")))
|
|
_bind(svc, "_project_default_branch", AsyncMock(return_value="master"))
|
|
|
|
order: list[str] = []
|
|
|
|
async def _slow_record(*_args: object, **_kwargs: object) -> None:
|
|
await asyncio.sleep(0.05)
|
|
order.append("record_done")
|
|
|
|
_bind(svc, "_record_pr_atomically", _slow_record)
|
|
|
|
fake_resp = MagicMock()
|
|
fake_resp.is_success = True
|
|
fake_resp.status_code = 201
|
|
fake_resp.json.return_value = {
|
|
"number": _EXPECTED_PR_NUMBER,
|
|
"html_url": f"https://github.com/acme/repo/pull/{_EXPECTED_PR_NUMBER}",
|
|
}
|
|
_bind(svc, "_post_pr", AsyncMock(return_value=fake_resp))
|
|
_bind(svc, "_apply_pr_labels", AsyncMock())
|
|
|
|
with _patch_project_service(fake_project):
|
|
task = asyncio.ensure_future(
|
|
svc.create_pr("feature/backend/abc12345", parent="master", is_root_pr=True)
|
|
)
|
|
await asyncio.sleep(0.01) # mid-record: cancellation lands in the shield
|
|
task.cancel()
|
|
# pytest.raises re-raises any OTHER exception type (e.g. the
|
|
# InterfaceError a racing rollback would surface), failing the test —
|
|
# that is assertion (a): CancelledError and nothing else propagates.
|
|
with pytest.raises(asyncio.CancelledError):
|
|
await task
|
|
# Appended synchronously right after propagation: no other coroutine
|
|
# can run in between, so this marker coming SECOND proves the record
|
|
# coroutine had already completed before the cancellation re-raised.
|
|
order.append("cancel_raised")
|
|
|
|
assert order == ["record_done", "cancel_raised"], (
|
|
f"record must complete BEFORE the cancellation re-raises; got {order}"
|
|
)
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_create_pr_raises_when_branch_not_found() -> None:
|
|
svc = _service()
|
|
_bind(svc, "_task_for_branch", AsyncMock(return_value=None))
|
|
with pytest.raises(NotFoundError):
|
|
await svc.create_pr("missing/branch", parent="master", is_root_pr=False)
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# _ensure_base_on_remote: create the PR base branch if it's missing on origin
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_ensure_base_creates_missing_base_off_default() -> None:
|
|
"""Missing base branch is created on origin off the default branch tip."""
|
|
svc = _service()
|
|
_bind(svc, "_project_default_branch", AsyncMock(return_value="master"))
|
|
calls: list[list[str]] = []
|
|
|
|
async def fake_run_git(_ws: Path, args: list[str], **_: object) -> MagicMock:
|
|
calls.append(args)
|
|
if args[0] == "ls-remote":
|
|
return MagicMock(stdout="", returncode=0, stderr="") # base absent
|
|
return MagicMock(stdout="", returncode=0, stderr="")
|
|
|
|
_bind(svc, "_run_git", fake_run_git)
|
|
out = await svc._ensure_base_on_remote(
|
|
Path("/tmp/ws"), "feature/frontend/abc--def", "roboco", "tok"
|
|
)
|
|
assert out == "feature/frontend/abc--def"
|
|
assert any(
|
|
a[0] == "push" and a[-1] == "origin/master:refs/heads/feature/frontend/abc--def"
|
|
for a in calls
|
|
), calls
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_ensure_base_passthrough_when_present() -> None:
|
|
"""An existing base branch is returned unchanged with no push."""
|
|
svc = _service()
|
|
_bind(svc, "_project_default_branch", AsyncMock(return_value="master"))
|
|
pushed = False
|
|
|
|
async def fake_run_git(_ws: Path, args: list[str], **_: object) -> MagicMock:
|
|
nonlocal pushed
|
|
if args[0] == "push":
|
|
pushed = True
|
|
if args[0] == "ls-remote":
|
|
return MagicMock(
|
|
stdout="sha\trefs/heads/feature/x", returncode=0, stderr=""
|
|
)
|
|
return MagicMock(stdout="", returncode=0, stderr="")
|
|
|
|
_bind(svc, "_run_git", fake_run_git)
|
|
out = await svc._ensure_base_on_remote(
|
|
Path("/tmp/ws"), "feature/x", "roboco", "tok"
|
|
)
|
|
assert out == "feature/x"
|
|
assert pushed is False
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_ensure_base_falls_back_to_default_when_create_fails() -> None:
|
|
"""If the create push fails, retarget to the default branch (never 422)."""
|
|
svc = _service()
|
|
_bind(svc, "_project_default_branch", AsyncMock(return_value="master"))
|
|
|
|
async def fake_run_git(_ws: Path, args: list[str], **_: object) -> MagicMock:
|
|
if args[0] == "ls-remote":
|
|
return MagicMock(stdout="", returncode=0, stderr="")
|
|
if args[0] == "push":
|
|
return MagicMock(stdout="", returncode=1, stderr="denied")
|
|
return MagicMock(stdout="", returncode=0, stderr="")
|
|
|
|
_bind(svc, "_run_git", fake_run_git)
|
|
out = await svc._ensure_base_on_remote(
|
|
Path("/tmp/ws"), "feature/x", "roboco", "tok"
|
|
)
|
|
assert out == "master"
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# _apply_pr_labels / _ensure_label_exists: never raise, even on a non-httpx
|
|
# error — labeling must not surface as a spurious tool failure after the PR
|
|
# itself was already created.
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
def _non_httpx_raising_client() -> MagicMock:
|
|
"""An AsyncClient whose POST raises a plain (non-httpx) exception."""
|
|
fake_client = MagicMock()
|
|
fake_client.__aenter__ = AsyncMock(return_value=fake_client)
|
|
fake_client.__aexit__ = AsyncMock(return_value=False)
|
|
fake_client.post = AsyncMock(side_effect=RuntimeError("boom"))
|
|
return fake_client
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_ensure_label_exists_swallows_non_httpx_error() -> None:
|
|
svc = _service()
|
|
with patch(
|
|
"roboco.services.git.httpx.AsyncClient",
|
|
return_value=_non_httpx_raising_client(),
|
|
):
|
|
await svc._ensure_label_exists(RepoRef("acme", "repo"), "tok", "cell/backend")
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_apply_pr_labels_swallows_non_httpx_error() -> None:
|
|
svc = _service()
|
|
_bind(svc, "_ensure_label_exists", AsyncMock())
|
|
with patch(
|
|
"roboco.services.git.httpx.AsyncClient",
|
|
return_value=_non_httpx_raising_client(),
|
|
):
|
|
await svc._apply_pr_labels(RepoRef("acme", "repo"), "tok", 11, ["cell/backend"])
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# pr_merge: returns merge commit dict
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_pr_merge_returns_merge_commit_dict() -> None:
|
|
project_id = uuid4()
|
|
fake_task = MagicMock(
|
|
project_id=project_id,
|
|
# Root task — no parent to lock; concurrency tests cover the
|
|
# parent-lock + retry-on-409 paths separately.
|
|
parent_task_id=None,
|
|
assigned_to=uuid4(),
|
|
work_session_id=None,
|
|
)
|
|
fake_project = MagicMock(slug="roboco")
|
|
result = MagicMock()
|
|
result.scalar_one_or_none.return_value = fake_task
|
|
|
|
svc = _service(execute_returns=result)
|
|
_bind(svc, "get_workspace", AsyncMock(return_value=Path("/tmp/ws")))
|
|
_bind(svc, "_get_project_token_or_raise", AsyncMock(return_value="tok"))
|
|
_bind(svc, "_parse_github_remote", MagicMock(return_value=RepoRef("acme", "repo")))
|
|
|
|
fake_resp = MagicMock(is_success=True, status_code=200)
|
|
_bind(svc, "_call_merge_api", AsyncMock(return_value=fake_resp))
|
|
_bind(svc, "_delete_pr_branch_best_effort", AsyncMock())
|
|
_bind(svc, "_sync_target_branch", AsyncMock(return_value="abc123sha"))
|
|
_bind(svc, "_project_default_branch", AsyncMock(return_value="master"))
|
|
|
|
# Merges flow UP the chain (cell -> Main-PM branch), never into master via
|
|
# this agent path — target is the integration branch, not the default branch.
|
|
with _patch_project_service(fake_project):
|
|
out = await svc.pr_merge(
|
|
11, target="feature/main_pm/root1234", project_id=project_id
|
|
)
|
|
assert out == {"merge_commit_sha": "abc123sha"}
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_pr_merge_into_default_branch_is_ceo_only() -> None:
|
|
"""The agent merge path refuses to merge into a repo's default branch."""
|
|
project_id = uuid4()
|
|
fake_task = MagicMock(
|
|
project_id=project_id, parent_task_id=None, assigned_to=uuid4()
|
|
)
|
|
fake_project = MagicMock(slug="roboco")
|
|
result = MagicMock()
|
|
result.scalar_one_or_none.return_value = fake_task
|
|
|
|
svc = _service(execute_returns=result)
|
|
_bind(svc, "get_workspace", AsyncMock(return_value=Path("/tmp/ws")))
|
|
_bind(svc, "_get_project_token_or_raise", AsyncMock(return_value="tok"))
|
|
_bind(svc, "_parse_github_remote", MagicMock(return_value=RepoRef("acme", "repo")))
|
|
_bind(svc, "_project_default_branch", AsyncMock(return_value="master"))
|
|
merge_api = AsyncMock()
|
|
_bind(svc, "_call_merge_api", merge_api)
|
|
|
|
with (
|
|
_patch_project_service(fake_project),
|
|
pytest.raises(UnauthorizedError, match="CEO_ONLY"),
|
|
):
|
|
await svc.pr_merge(11, target="master", project_id=project_id)
|
|
# Guard fires before any GitHub merge call.
|
|
merge_api.assert_not_called()
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# commit: stages + commits a large changeset with the longer git timeout
|
|
# (issue #13 — the panel commit verb timed out on the 30s default budget).
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_commit_uses_longer_timeout_for_staging_and_commit() -> None:
|
|
"""`add`/`commit` must run with the commit-timeout, not the default.
|
|
|
|
Large multi-file changesets exceeded the 30s default git timeout. The
|
|
staging (`git add`) and `git commit` ops now pass
|
|
`settings.git_commit_timeout_seconds` so big changesets don't time out.
|
|
"""
|
|
svc = _service()
|
|
_bind(svc, "_workspace_for_branch", AsyncMock(return_value=Path("/tmp/ws")))
|
|
_bind(svc, "_assert_on_task_branch", AsyncMock())
|
|
_bind(svc, "_ensure_worktree_for_commit", AsyncMock())
|
|
_bind(svc, "_task_for_branch", AsyncMock(return_value=None))
|
|
_bind(svc, "_parse_commit_stats", MagicMock(return_value=(1, 0, 1)))
|
|
|
|
timeouts_by_subcmd: dict[str, int | None] = {}
|
|
|
|
async def _run_git(
|
|
_workspace: Path,
|
|
args: list[str],
|
|
check: bool = True,
|
|
token: str | None = None,
|
|
timeout: int | None = None,
|
|
) -> MagicMock:
|
|
del check, token
|
|
timeouts_by_subcmd[args[0]] = timeout
|
|
if args[:2] == ["log", "-1"]:
|
|
return MagicMock(stdout="deadbeef|feat: big change\n", returncode=0)
|
|
return MagicMock(stdout="", returncode=0)
|
|
|
|
_bind(svc, "_run_git", AsyncMock(side_effect=_run_git))
|
|
|
|
out = await svc.commit(
|
|
branch_name="feature/frontend/abc12345",
|
|
message="implement the panel dashboard layout and routing",
|
|
task_id=uuid4(),
|
|
)
|
|
|
|
assert out["sha"] == "deadbeef"
|
|
# Staging + commit ran with the longer commit budget...
|
|
assert timeouts_by_subcmd["add"] == settings.git_commit_timeout_seconds
|
|
assert timeouts_by_subcmd["commit"] == settings.git_commit_timeout_seconds
|
|
# ...while the cheap read-only ops kept the default (None → default budget).
|
|
assert timeouts_by_subcmd["log"] is None
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_push_restates_gh001_as_permanent() -> None:
|
|
"""A >100MB push rejection (GH001) is re-raised with a clear, permanent
|
|
message that points at i_am_blocked — not the raw output an agent mis-reads
|
|
as a transient timeout and blind-retries."""
|
|
svc = _service()
|
|
_bind(svc, "get_current_branch", AsyncMock(return_value="feature/x"))
|
|
_bind(svc, "_token_for_workspace", AsyncMock(return_value=None))
|
|
|
|
async def _run_git(_workspace: object, args: list[str], **_kw: object) -> object:
|
|
if args[:1] == ["push"]:
|
|
raise GitCommandError(
|
|
"git push",
|
|
"remote: error: GH001: large.bin is 115.00 MB; this exceeds "
|
|
"GitHub's file size limit of 100.00 MB",
|
|
)
|
|
return MagicMock(returncode=0, stdout="1", stderr="")
|
|
|
|
_bind(svc, "_run_git", AsyncMock(side_effect=_run_git))
|
|
with pytest.raises(GitCommandError, match="i_am_blocked"):
|
|
await svc.push(Path("/tmp/ws"))
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_push_propagates_non_gh001_error_unchanged() -> None:
|
|
"""A non-size push failure is re-raised as-is (not reclassified)."""
|
|
svc = _service()
|
|
_bind(svc, "get_current_branch", AsyncMock(return_value="feature/x"))
|
|
_bind(svc, "_token_for_workspace", AsyncMock(return_value=None))
|
|
|
|
async def _run_git(_workspace: object, args: list[str], **_kw: object) -> object:
|
|
if args[:1] == ["push"]:
|
|
raise GitCommandError("git push", "fatal: Authentication failed")
|
|
return MagicMock(returncode=0, stdout="1", stderr="")
|
|
|
|
_bind(svc, "_run_git", AsyncMock(side_effect=_run_git))
|
|
with pytest.raises(GitCommandError, match="Authentication failed"):
|
|
await svc.push(Path("/tmp/ws"))
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# _sync_target_branch fallback
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_sync_target_branch_uses_local_ref_when_present() -> None:
|
|
"""If the target branch exists locally, checkout + hard-sync to origin."""
|
|
svc = _service()
|
|
calls: list[list[str]] = []
|
|
|
|
async def _run_git(_workspace: object, args: list[str], **_kw: object) -> object:
|
|
calls.append(args)
|
|
if args[:2] == ["checkout", "feature/backend/parent"]:
|
|
return MagicMock(returncode=0, stdout="", stderr="")
|
|
if args[:2] == ["log", "-1"]:
|
|
return MagicMock(returncode=0, stdout="local-tip-sha", stderr="")
|
|
return MagicMock(returncode=0, stdout="", stderr="")
|
|
|
|
_bind(svc, "_run_git", AsyncMock(side_effect=_run_git))
|
|
sha = await svc._sync_target_branch(
|
|
Path("/tmp/ws"), "feature/backend/parent", "token"
|
|
)
|
|
assert sha == "local-tip-sha"
|
|
assert ["checkout", "feature/backend/parent"] in calls
|
|
assert ["fetch", "origin", "feature/backend/parent"] in calls
|
|
assert ["reset", "--hard", "origin/feature/backend/parent"] in calls
|
|
assert ["pull"] not in calls
|
|
assert ["checkout", "-b", "feature/backend/parent"] not in [c[:3] for c in calls]
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_sync_target_branch_fetches_and_tracks_when_local_ref_missing() -> None:
|
|
"""A parent branch that only exists on origin is fetched and tracked."""
|
|
svc = _service()
|
|
calls: list[list[str]] = []
|
|
|
|
async def _run_git(_workspace: object, args: list[str], **_kw: object) -> object:
|
|
calls.append(args)
|
|
if args[:2] == ["checkout", "feature/backend/parent"]:
|
|
return MagicMock(returncode=1, stdout="", stderr="pathspec did not match")
|
|
if args[:2] == ["fetch", "origin"]:
|
|
return MagicMock(returncode=0, stdout="", stderr="")
|
|
if args[:3] == ["checkout", "-b", "feature/backend/parent"]:
|
|
return MagicMock(returncode=0, stdout="", stderr="")
|
|
if args[:2] == ["log", "-1"]:
|
|
return MagicMock(returncode=0, stdout="origin-tip-sha", stderr="")
|
|
return MagicMock(returncode=0, stdout="", stderr="")
|
|
|
|
_bind(svc, "_run_git", AsyncMock(side_effect=_run_git))
|
|
sha = await svc._sync_target_branch(
|
|
Path("/tmp/ws"), "feature/backend/parent", "token"
|
|
)
|
|
assert sha == "origin-tip-sha"
|
|
assert ["checkout", "feature/backend/parent"] in calls
|
|
assert ["fetch", "origin", "feature/backend/parent"] in calls
|
|
assert [
|
|
"checkout",
|
|
"-b",
|
|
"feature/backend/parent",
|
|
"origin/feature/backend/parent",
|
|
] in calls
|
|
assert ["reset", "--hard", "origin/feature/backend/parent"] in calls
|
|
assert ["pull"] not in calls
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_sync_target_branch_raises_when_origin_also_missing() -> None:
|
|
"""If the branch is missing locally AND on origin, raise a clear GitError."""
|
|
svc = _service()
|
|
|
|
async def _run_git(_workspace: object, args: list[str], **_kw: object) -> object:
|
|
if args[:2] == ["checkout", "feature/backend/parent"]:
|
|
return MagicMock(returncode=1, stdout="", stderr="local missing")
|
|
if args[:2] == ["fetch", "origin"]:
|
|
return MagicMock(returncode=0, stdout="", stderr="")
|
|
if args[:3] == ["checkout", "-b", "feature/backend/parent"]:
|
|
return MagicMock(returncode=1, stdout="", stderr="origin missing")
|
|
return MagicMock(returncode=0, stdout="", stderr="")
|
|
|
|
_bind(svc, "_run_git", AsyncMock(side_effect=_run_git))
|
|
with pytest.raises(GitError, match="Could not check out target branch"):
|
|
await svc._sync_target_branch(
|
|
Path("/tmp/ws"), "feature/backend/parent", "token"
|
|
)
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# _sync_target_branch_best_effort — post-merge local sync must never re-block
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_sync_target_branch_best_effort_swallows_missing_branch() -> None:
|
|
"""A post-merge local sync of a target branch gone from origin must NOT raise.
|
|
|
|
``pr_merge`` / ``merge_pull_request`` reach the post-merge sync only after the
|
|
authoritative GitHub merge already succeeded, so updating the local workspace
|
|
copy of the (possibly-deleted) target branch is cosmetic. Letting it raise
|
|
re-blocks the just-merged task and respawn-loops the PM — the live failure
|
|
where an integration branch deleted from origin made ``complete()`` loop on
|
|
``fetch origin <cell-branch> — fatal: couldn't find remote ref``.
|
|
"""
|
|
svc = _service()
|
|
_bind(
|
|
svc,
|
|
"_sync_target_branch",
|
|
AsyncMock(
|
|
side_effect=GitCommandError(
|
|
"fetch origin feature/backend/31ae12fc--0e49e04e",
|
|
"fatal: couldn't find remote ref feature/backend/31ae12fc--0e49e04e",
|
|
)
|
|
),
|
|
)
|
|
result = await svc._sync_target_branch_best_effort(
|
|
Path("/tmp/ws"), "feature/backend/31ae12fc--0e49e04e", "token"
|
|
)
|
|
assert result is None
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_sync_target_branch_best_effort_returns_sha_on_success() -> None:
|
|
"""On success it passes the synced tip sha straight through."""
|
|
svc = _service()
|
|
_bind(svc, "_sync_target_branch", AsyncMock(return_value="merged-tip-sha"))
|
|
result = await svc._sync_target_branch_best_effort(
|
|
Path("/tmp/ws"), "feature/backend/parent", "token"
|
|
)
|
|
assert result == "merged-tip-sha"
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# rebase_onto_base — clean-tree gate (mirrors pull)
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_rebase_onto_base_refuses_dirty_worktree() -> None:
|
|
"""Dirty worktree → ValidationError(DIRTY_WORKSPACE); tree untouched."""
|
|
svc = _service()
|
|
calls: list[list[str]] = []
|
|
|
|
async def _run_git(_ws: object, args: list[str], **_kw: object) -> MagicMock:
|
|
calls.append(args)
|
|
res = MagicMock()
|
|
res.returncode = 0
|
|
res.stdout = " M dirty.py\n" if args[:2] == ["status", "--porcelain"] else ""
|
|
return res
|
|
|
|
_bind(svc, "_run_git", AsyncMock(side_effect=_run_git))
|
|
|
|
with pytest.raises(ValidationError, match="DIRTY_WORKSPACE"):
|
|
await svc.rebase_onto_base(
|
|
Path("/tmp/ws"),
|
|
head_branch="feature/backend/h",
|
|
base_branch="master",
|
|
git_token="t",
|
|
)
|
|
|
|
# Only the status probe ran — no fetch/checkout/reset/rebase touched the tree.
|
|
assert calls == [["status", "--porcelain"]]
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_rebase_onto_base_proceeds_on_clean_tree() -> None:
|
|
"""Clean worktree → rebase runs; superseded when head has no unique commits."""
|
|
svc = _service()
|
|
calls: list[list[str]] = []
|
|
|
|
async def _run_git(_ws: object, args: list[str], **_kw: object) -> MagicMock:
|
|
calls.append(args)
|
|
res = MagicMock()
|
|
res.returncode = 0
|
|
if args[:2] == ["status", "--porcelain"]:
|
|
res.stdout = ""
|
|
elif args[:2] == ["rev-list", "--count"]:
|
|
res.stdout = "0"
|
|
else:
|
|
res.stdout = ""
|
|
return res
|
|
|
|
_bind(svc, "_run_git", AsyncMock(side_effect=_run_git))
|
|
|
|
result = await svc.rebase_onto_base(
|
|
Path("/tmp/ws"),
|
|
head_branch="feature/backend/h",
|
|
base_branch="master",
|
|
git_token="t",
|
|
)
|
|
|
|
assert result == {"status": "superseded"}
|
|
# Gate ran first, then the normal fetch/checkout/reset/rebase sequence.
|
|
assert calls[0] == ["status", "--porcelain"]
|
|
assert ["fetch", "origin"] in calls
|
|
assert ["rebase", "origin/master"] in calls
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# rebase_onto_base — stash=True auto-stash/pop (the dirty-workspace exit)
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_rebase_onto_base_stash_true_auto_stashes_and_pops() -> None:
|
|
"""stash=True: a dirty tree is stashed (not refused), rebased, popped back."""
|
|
svc = _service()
|
|
calls: list[list[str]] = []
|
|
|
|
async def _run_git(_ws: object, args: list[str], **_kw: object) -> MagicMock:
|
|
calls.append(args)
|
|
res = MagicMock()
|
|
res.returncode = 0
|
|
if args[:2] == ["status", "--porcelain"]:
|
|
res.stdout = " M dirty.py\n"
|
|
elif args[:2] == ["rev-list", "--count"]:
|
|
# Only the post-rebase unique-vs-base count is non-zero; the
|
|
# pre-rebase local-vs-origin(HEAD) classification reads as
|
|
# "nothing unique on either side" (behind/equal, not diverged).
|
|
res.stdout = "1" if args[2] == "origin/master..HEAD" else "0"
|
|
else:
|
|
res.stdout = ""
|
|
return res
|
|
|
|
_bind(svc, "_run_git", AsyncMock(side_effect=_run_git))
|
|
|
|
result = await svc.rebase_onto_base(
|
|
Path("/tmp/ws"),
|
|
head_branch="feature/backend/h",
|
|
base_branch="master",
|
|
git_token="t",
|
|
stash=True,
|
|
)
|
|
|
|
assert result == {"status": "rebased", "unique_commits": 1}
|
|
push_args = ["stash", "push", "-u", "-m", "sync_branch autostash"]
|
|
pop_args = ["stash", "pop"]
|
|
assert push_args in calls
|
|
assert pop_args in calls
|
|
# Stash push runs before the rebase, pop runs after.
|
|
assert calls.index(push_args) < calls.index(["rebase", "origin/master"])
|
|
assert calls.index(pop_args) > calls.index(["rebase", "origin/master"])
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_rebase_onto_base_stash_pop_conflict_preserves_stash() -> None:
|
|
"""A conflicted pop is flagged, never auto-resolved — stash stays intact."""
|
|
svc = _service()
|
|
|
|
async def _run_git(_ws: object, args: list[str], **_kw: object) -> MagicMock:
|
|
res = MagicMock()
|
|
res.returncode = 0
|
|
if args[:2] == ["status", "--porcelain"]:
|
|
res.stdout = " M dirty.py\n"
|
|
elif args[:2] == ["rev-list", "--count"]:
|
|
# Only the post-rebase unique-vs-base count is non-zero; the
|
|
# pre-rebase local-vs-origin(HEAD) classification reads as
|
|
# "nothing unique on either side" (behind/equal, not diverged).
|
|
res.stdout = "1" if args[2] == "origin/master..HEAD" else "0"
|
|
elif args == ["stash", "pop"]:
|
|
res.returncode = 1 # pop conflicted — stash is NOT dropped by git
|
|
else:
|
|
res.stdout = ""
|
|
return res
|
|
|
|
_bind(svc, "_run_git", AsyncMock(side_effect=_run_git))
|
|
|
|
result = await svc.rebase_onto_base(
|
|
Path("/tmp/ws"),
|
|
head_branch="feature/backend/h",
|
|
base_branch="master",
|
|
git_token="t",
|
|
stash=True,
|
|
)
|
|
|
|
assert result == {
|
|
"status": "rebased",
|
|
"unique_commits": 1,
|
|
"stash_pop_conflict": True,
|
|
}
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_rebase_onto_base_stash_true_rebase_conflict_skips_pop() -> None:
|
|
"""A rebase conflict aborts before ever attempting the pop — no double
|
|
conflict; the stash is reported preserved for the caller to surface."""
|
|
svc = _service()
|
|
calls: list[list[str]] = []
|
|
|
|
async def _run_git(_ws: object, args: list[str], **_kw: object) -> MagicMock:
|
|
calls.append(args)
|
|
res = MagicMock()
|
|
res.returncode = 0
|
|
if args[:2] == ["status", "--porcelain"]:
|
|
res.stdout = " M dirty.py\n"
|
|
elif args == ["rebase", "origin/master"]:
|
|
res.returncode = 1
|
|
elif args[:2] == ["diff", "--name-only"]:
|
|
res.stdout = "src/a.py\n"
|
|
else:
|
|
res.stdout = ""
|
|
return res
|
|
|
|
_bind(svc, "_run_git", AsyncMock(side_effect=_run_git))
|
|
|
|
result = await svc.rebase_onto_base(
|
|
Path("/tmp/ws"),
|
|
head_branch="feature/backend/h",
|
|
base_branch="master",
|
|
git_token="t",
|
|
stash=True,
|
|
)
|
|
|
|
assert result == {
|
|
"status": "conflicts",
|
|
"files": ["src/a.py"],
|
|
"stash_preserved": True,
|
|
}
|
|
assert ["stash", "pop"] not in calls
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# _link_commit_to_task — flush; the runner commits (no out-of-band commit)
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_link_commit_to_task_does_not_commit_session() -> None:
|
|
"""_link_commit_to_task must flush but not commit out-of-band.
|
|
|
|
The verb runner owns the transaction boundary; an out-of-band commit
|
|
here would release the runner's savepoint and drag in pending
|
|
orchestrator state.
|
|
"""
|
|
session = _make_session()
|
|
svc = GitService(session)
|
|
|
|
fake_task_service = MagicMock()
|
|
fake_task = MagicMock(work_session_id=uuid4())
|
|
fake_task_service.get = AsyncMock(return_value=fake_task)
|
|
fake_task_service.add_commit = AsyncMock()
|
|
|
|
fake_ws_service = MagicMock()
|
|
fake_ws_service.add_commit = AsyncMock()
|
|
|
|
with (
|
|
patch("roboco.services.git.get_task_service", return_value=fake_task_service),
|
|
patch(
|
|
"roboco.services.git.get_work_session_service",
|
|
return_value=fake_ws_service,
|
|
),
|
|
):
|
|
await svc._link_commit_to_task(uuid4(), "deadbeef", "msg", uuid4())
|
|
|
|
session.flush.assert_awaited()
|
|
session.commit.assert_not_awaited()
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_link_commit_to_task_swallows_errors_without_commit() -> None:
|
|
"""Even on failure the session is not committed by the link path."""
|
|
session = _make_session()
|
|
svc = GitService(session)
|
|
|
|
fake_task_service = MagicMock()
|
|
fake_task_service.get = AsyncMock(side_effect=RuntimeError("boom"))
|
|
|
|
with patch("roboco.services.git.get_task_service", return_value=fake_task_service):
|
|
await svc._link_commit_to_task(uuid4(), "deadbeef", "msg", uuid4())
|
|
|
|
session.commit.assert_not_awaited()
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# M38: _pr_is_merged returns None on httpx.HTTPError (indeterminate, not
|
|
# False). Callers treat None as "assume merged" and fall through to the
|
|
# already-merged cleanup path instead of raising MergeConflictError / GitError
|
|
# and respawning the PM against an already-merged PR.
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
def _httpx_raising_client() -> MagicMock:
|
|
"""An AsyncClient whose GET raises httpx.HTTPError (network indeterminate)."""
|
|
fake_client = MagicMock()
|
|
fake_client.__aenter__ = AsyncMock(return_value=fake_client)
|
|
fake_client.__aexit__ = AsyncMock(return_value=False)
|
|
fake_client.get = AsyncMock(side_effect=httpx.HTTPError("network indeterminate"))
|
|
return fake_client
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_pr_is_merged_returns_none_on_httpx_error() -> None:
|
|
"""On httpx.HTTPError the lookup is indeterminate -> None, not False."""
|
|
svc = _service()
|
|
with patch(
|
|
"roboco.services.git.httpx.AsyncClient",
|
|
return_value=_httpx_raising_client(),
|
|
):
|
|
out = await svc._pr_is_merged(RepoRef("acme", "repo"), 11, "tok")
|
|
assert out is None
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_merge_with_retry_none_does_not_raise_merge_conflict() -> None:
|
|
"""Agent merge path: indeterminate (None) falls through, not conflict."""
|
|
svc = _service()
|
|
_bind(svc, "_first_allowed_merge_method", AsyncMock(return_value=None))
|
|
# 405 -> disambiguation path -> _pr_is_merged returns None -> fall through.
|
|
resp_405 = MagicMock(is_success=False, status_code=405, text="not allowed")
|
|
_bind(svc, "_call_merge_api", AsyncMock(return_value=resp_405))
|
|
_bind(svc, "_pr_is_merged", AsyncMock(return_value=None))
|
|
|
|
ctx = GitService._MergeContext(
|
|
repo_ref=RepoRef("acme", "repo"),
|
|
pr_number=11,
|
|
git_token="tok",
|
|
workspace=Path("/tmp/ws"),
|
|
target="feature/main_pm/root1",
|
|
)
|
|
# None must NOT raise MergeConflictError; it returns the failed resp
|
|
# (idempotent-success fall-through, same as the already-merged True path).
|
|
out = await svc._merge_with_retry(ctx)
|
|
assert out is resp_405
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_merge_with_retry_false_raises_merge_conflict() -> None:
|
|
"""A real False (PR not merged) still raises MergeConflictError."""
|
|
svc = _service()
|
|
_bind(svc, "_first_allowed_merge_method", AsyncMock(return_value=None))
|
|
resp_405 = MagicMock(is_success=False, status_code=405, text="not mergeable")
|
|
_bind(svc, "_call_merge_api", AsyncMock(return_value=resp_405))
|
|
_bind(svc, "_pr_is_merged", AsyncMock(return_value=False))
|
|
|
|
ctx = GitService._MergeContext(
|
|
repo_ref=RepoRef("acme", "repo"),
|
|
pr_number=11,
|
|
git_token="tok",
|
|
workspace=Path("/tmp/ws"),
|
|
target="feature/main_pm/root1",
|
|
)
|
|
with pytest.raises(MergeConflictError):
|
|
await svc._merge_with_retry(ctx)
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_merge_pull_request_none_does_not_raise_git_error() -> None:
|
|
"""CEO merge path: indeterminate (None) falls through to cleanup, not GitError."""
|
|
svc = _service()
|
|
_bind(svc, "_get_project_token_or_raise", AsyncMock(return_value="tok"))
|
|
_bind(svc, "_parse_github_remote", MagicMock(return_value=RepoRef("acme", "repo")))
|
|
_bind(svc, "_first_allowed_merge_method", AsyncMock(return_value=None))
|
|
_bind(svc, "_delete_pr_branch_best_effort", AsyncMock())
|
|
_bind(svc, "_sync_target_branch", AsyncMock(return_value="abc123sha"))
|
|
_bind(svc, "_project_default_branch", AsyncMock(return_value="master"))
|
|
resp_405 = MagicMock(is_success=False, status_code=405, text="not allowed")
|
|
_bind(svc, "_call_merge_api", AsyncMock(return_value=resp_405))
|
|
_bind(svc, "_pr_is_merged", AsyncMock(return_value=None))
|
|
|
|
out = await svc.merge_pull_request(Path("/tmp/ws"), 11, "squash", "roboco")
|
|
assert out == ("master", "abc123sha")
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_is_pr_merged_for_task_none_treated_as_merged() -> None:
|
|
"""is_pr_merged_for_task coerces None -> True so choreographer skips pr_merge."""
|
|
project_id = uuid4()
|
|
fake_task = MagicMock(project_id=project_id, pr_number=11, parent_task_id=None)
|
|
fake_project = MagicMock(slug="roboco")
|
|
result = MagicMock()
|
|
result.scalar_one_or_none.return_value = fake_task
|
|
|
|
svc = _service(execute_returns=result)
|
|
_bind(svc, "get_workspace", AsyncMock(return_value=Path("/tmp/ws")))
|
|
_bind(svc, "_get_project_token_or_raise", AsyncMock(return_value="tok"))
|
|
_bind(svc, "_parse_github_remote", MagicMock(return_value=RepoRef("acme", "repo")))
|
|
_bind(svc, "_project_for_task", AsyncMock(return_value=fake_project))
|
|
_bind(svc, "_resolve_workspace_agent_id", MagicMock(return_value=None))
|
|
_bind(svc, "_pr_is_merged", AsyncMock(return_value=None))
|
|
|
|
with _patch_project_service(fake_project):
|
|
out = await svc.is_pr_merged_for_task(fake_task.id)
|
|
assert out is True
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# L1: actor_agent_id threading + narrowed created_by fallback
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
def test_resolve_workspace_agent_id_no_created_by_fallback_when_actor_none() -> None:
|
|
"""_resolve_workspace_agent_id(None) must NOT fall back to created_by.
|
|
|
|
A PM who created the task but never cloned the project's workspace
|
|
would 404 on get_workspace(PM-id). With the actor unset we prefer
|
|
None (project.workspace_path) over a creator who has no clone.
|
|
"""
|
|
pm_id = uuid4()
|
|
task = MagicMock(assigned_to=None, created_by=pm_id)
|
|
assert GitService._resolve_workspace_agent_id(task, None) is None
|
|
|
|
|
|
def test_resolve_workspace_agent_id_actor_precedes_assigned_and_creator() -> None:
|
|
"""The threaded actor wins over assigned_to and created_by."""
|
|
actor = uuid4()
|
|
assignee = uuid4()
|
|
creator = uuid4()
|
|
task = MagicMock(assigned_to=assignee, created_by=creator)
|
|
assert GitService._resolve_workspace_agent_id(task, actor) == actor
|
|
|
|
|
|
def test_resolve_workspace_agent_id_assigned_to_used_when_actor_none() -> None:
|
|
"""assigned_to is still the fallback when the actor is unset."""
|
|
assignee = uuid4()
|
|
creator = uuid4()
|
|
task = MagicMock(assigned_to=assignee, created_by=creator)
|
|
assert GitService._resolve_workspace_agent_id(task, None) == assignee
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_update_pr_for_task_threads_actor_agent_id() -> None:
|
|
"""update_pr_for_task forwards actor_agent_id to workspace resolution.
|
|
|
|
A PM (not the assignee) editing the PR must resolve to the PM's own
|
|
workspace, not fall back to assigned_to/created_by. The actor is the
|
|
agent who actually performed the action — the verb layer passes it.
|
|
"""
|
|
pm_id = uuid4()
|
|
task = MagicMock(
|
|
id=uuid4(),
|
|
project_id=uuid4(),
|
|
pr_number=7,
|
|
pr_url="https://github.com/acme/repo/pull/7",
|
|
assigned_to=uuid4(),
|
|
created_by=uuid4(),
|
|
)
|
|
|
|
svc = _service()
|
|
captured: dict[str, object] = {}
|
|
|
|
async def _capture_workspace(_slug: str, agent_id: UUID | None = None) -> Path:
|
|
captured["agent_id"] = agent_id
|
|
return Path("/tmp/ws")
|
|
|
|
_bind(svc, "get_workspace", AsyncMock(side_effect=_capture_workspace))
|
|
_bind(svc, "_parse_github_remote", MagicMock(return_value=RepoRef("acme", "repo")))
|
|
_bind(svc, "_get_project_token_or_raise", AsyncMock(return_value="tok"))
|
|
|
|
fake_task_service = MagicMock()
|
|
fake_task_service.get = AsyncMock(return_value=task)
|
|
fake_project = MagicMock(slug="roboco")
|
|
|
|
patch_resp = MagicMock()
|
|
patch_resp.status_code = 200
|
|
patch_resp.is_success = True
|
|
patch_resp.json.return_value = {"number": 7, "html_url": task.pr_url}
|
|
patch_resp.text = ""
|
|
fake_client = MagicMock()
|
|
fake_client.__aenter__ = AsyncMock(return_value=fake_client)
|
|
fake_client.__aexit__ = AsyncMock(return_value=False)
|
|
fake_client.patch = AsyncMock(return_value=patch_resp)
|
|
fake_client.post = AsyncMock()
|
|
|
|
with (
|
|
patch("roboco.services.git.get_task_service", return_value=fake_task_service),
|
|
_patch_project_service(fake_project),
|
|
patch("roboco.services.git.httpx.AsyncClient", return_value=fake_client),
|
|
):
|
|
await svc.update_pr_for_task(
|
|
UUID(str(task.id)),
|
|
title="t",
|
|
body=None,
|
|
reviewers=None,
|
|
actor_agent_id=pm_id,
|
|
)
|
|
|
|
assert captured["agent_id"] == pm_id
|