mirror of
https://github.com/rennf93/roboco.git
synced 2026-08-03 07:23:24 +02:00
Renn F
4d4bf084c5
Convention: no type:ignore/noqa, and pre-existing violations still violate. The make-quality gate runs 'mypy roboco/ tests/', but the prior commits' gates only ran mypy on production files, masking 64 type errors across 15 test files (method-assign, unused-ignore, no-untyped-def, attr-defined, union-attr, has-type, index, misc). Fixed without any type:ignore: - method-assign (svc.session.X = / svc.method = AsyncMock()): hold a local 'session: MagicMock'/'AsyncMock' and assert on it, or stub via object.__setattr__ / monkeypatch / a typed '_bind' helper returning Any, or alias 'cc: Any = c' (the pattern the file already used). - unused 'type: ignore[assignment]' (real code was method-assign): removed; replaced with the no-suppression patterns above. - 'Callable[...] has no attribute assert_*': keep a typed local ref to the AsyncMock and assert on the local, not the method-typed attr. - no-untyped-def: annotate helper params (Any / pytest.MonkeyPatch). - attr-defined / index / union-attr: type the helper as Any, narrow with an 'is not None' assert, or add the missing attr to a fake. - has-type / return-value: fix the declared return type to the tuple the function actually returns. - PLC0415 inline imports: hoisted to top-level. test_pr_gate_notifies_pm._stub_gate_path converted fully to the 'cc: Any = c' alias (it already used it for one attr) so its five '# type: ignore[method-assign]' suppressions are gone. mypy tests/: 64 errors -> 0 (538 files). ruff check tests/: clean. All 84 tests in the touched files pass.
116 lines
4.2 KiB
Python
116 lines
4.2 KiB
Python
"""F019 — a git mutation op killed by ``_run_git``'s timeout orphans lock files.
|
|
|
|
``subprocess.run(..., timeout=...)`` sends SIGKILL on timeout. A git mutation
|
|
(commit / merge --ff-only / rebase / reset --hard / add) killed mid-write
|
|
orphaned ``.git/index.lock`` (+ ``HEAD.lock`` / ``refs/**.lock`` /
|
|
``packed-refs.lock``), wedging the workspace for every subsequent op —
|
|
including the next fresh-claim ``reset --hard`` — with
|
|
"Another git process seems to be running in this repository". The fix
|
|
best-effort removes stale ``.git/**/*.lock`` files in the timeout branch
|
|
before re-raising, since the git process is dead by the time the timeout
|
|
fires.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import subprocess
|
|
from typing import TYPE_CHECKING
|
|
from unittest.mock import MagicMock
|
|
|
|
import pytest
|
|
from roboco.exceptions import GitTimeoutError
|
|
from roboco.services.git import GitService
|
|
|
|
if TYPE_CHECKING:
|
|
from pathlib import Path
|
|
|
|
|
|
def _svc() -> GitService:
|
|
return GitService(MagicMock())
|
|
|
|
|
|
def _seed_locks(workspace: Path) -> dict[str, Path]:
|
|
"""Create a realistic set of orphaned git lock files under .git/."""
|
|
git_dir = workspace / ".git"
|
|
refs_heads = git_dir / "refs" / "heads"
|
|
refs_heads.mkdir(parents=True, exist_ok=True)
|
|
locks = {
|
|
"index": git_dir / "index.lock",
|
|
"head": git_dir / "HEAD.lock",
|
|
"packed_refs": git_dir / "packed-refs.lock",
|
|
"ref": refs_heads / "feature.lock",
|
|
}
|
|
for p in locks.values():
|
|
p.write_text("stale")
|
|
# A non-lock file that must be left untouched.
|
|
keep = git_dir / "config"
|
|
keep.write_text("[core]\n")
|
|
return {**locks, "keep_config": keep}
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_timeout_removes_stale_git_locks(
|
|
tmp_path: Path, monkeypatch: pytest.MonkeyPatch
|
|
) -> None:
|
|
"""A timed-out git op clears orphaned .git locks before re-raising."""
|
|
workspace = tmp_path / "ws"
|
|
(workspace / ".git").mkdir(parents=True)
|
|
locks = _seed_locks(workspace)
|
|
|
|
def _boom(*_a: object, **_k: object) -> subprocess.CompletedProcess[str]:
|
|
raise subprocess.TimeoutExpired(cmd=["git", "commit"], timeout=5)
|
|
|
|
monkeypatch.setattr("roboco.services.git.subprocess.run", _boom)
|
|
|
|
with pytest.raises(GitTimeoutError):
|
|
await _svc()._run_git(workspace, ["commit", "-m", "x"], check=True)
|
|
|
|
# Every orphaned lock file is gone — the workspace is un-wedged.
|
|
for name in ("index", "head", "packed_refs", "ref"):
|
|
assert not locks[name].exists(), f"{name} lock was not cleaned up"
|
|
# Non-lock .git files are untouched.
|
|
assert locks["keep_config"].exists()
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_timeout_lock_cleanup_is_best_effort_no_git_dir(
|
|
tmp_path: Path, monkeypatch: pytest.MonkeyPatch
|
|
) -> None:
|
|
"""A timeout with no .git/ directory must not error the cleanup path."""
|
|
workspace = tmp_path / "ws"
|
|
workspace.mkdir()
|
|
|
|
def _boom(*_a: object, **_k: object) -> subprocess.CompletedProcess[str]:
|
|
raise subprocess.TimeoutExpired(cmd=["git", "reset", "--hard"], timeout=5)
|
|
|
|
monkeypatch.setattr("roboco.services.git.subprocess.run", _boom)
|
|
|
|
with pytest.raises(GitTimeoutError):
|
|
await _svc()._run_git(workspace, ["reset", "--hard", "origin/main"])
|
|
# No crash — that's the assertion (best-effort cleanup on a missing .git).
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_clean_exit_does_not_touch_locks(
|
|
tmp_path: Path, monkeypatch: pytest.MonkeyPatch
|
|
) -> None:
|
|
"""A normal (non-timed-out) git op must NOT delete lock files — a concurrent
|
|
real git process could be holding one. Cleanup is timeout-only."""
|
|
workspace = tmp_path / "ws"
|
|
(workspace / ".git").mkdir(parents=True)
|
|
locks = _seed_locks(workspace)
|
|
|
|
ok = subprocess.CompletedProcess(
|
|
args=["git", "status"], returncode=0, stdout="", stderr=""
|
|
)
|
|
monkeypatch.setattr("roboco.services.git.subprocess.run", lambda *_a, **_k: ok)
|
|
# _ensure_agent_owned runs after a clean exit — no-op it.
|
|
monkeypatch.setattr(
|
|
"roboco.services.workspace._ensure_agent_owned", lambda _ws: None
|
|
)
|
|
|
|
await _svc()._run_git(workspace, ["status"], check=True)
|
|
|
|
for name in ("index", "head", "packed_refs", "ref"):
|
|
assert locks[name].exists(), f"{name} lock was wrongly removed on clean exit"
|