mirror of
https://github.com/rennf93/roboco.git
synced 2026-08-03 07:23:24 +02:00
Renn F
ce4d02b3c2
Evidence-assembly git legs (diff, changed-files, branch fetch, advisory conventions run) ran unbounded inside claim_review / claim_doc_task / claim_gate_review / evidence() / i_am_done's envelope build, so a slow clone turned the whole verb into a silent 120s FlowVerbTimeout 504. Each leg now runs through run_bounded_leg under a shared LegBudget (evidence_assembly_timeout_seconds, 45s total): a timed-out leg — both asyncio TimeoutError and git's own GitTimeoutError — degrades into an evidence_gaps note on the envelope instead of hanging the verb, while non-timeout git errors still propagate. The advisory conventions run gets an inner-only timeout (conventions_validator_advisory_timeout_ seconds, 30s) threaded down to the subprocess so it is never orphaned by an outer cancel; the fail-closed i_am_done/pr_pass conventions gates keep their hardcoded 120s. _ensure_pm_decision now reports a PmDecisionOutcome: a transient DB failure recording the PM's decision journal (e.g. lock timeout under load) no longer launders into a journal:decision gate rejection that escalates and BLOCKS the task — the verb's own rationale satisfies the gate with a structured warning, across all seven PM verbs. Also: repo-wide ruff realignment to the lockfile-pinned ruff (8 format-only diffs, 14 UP038 isinstance conversions) that a transiently newer venv ruff had masked. Gate: 15474 passed, 459 skipped; ruff/mypy/xenon/vulture/bandit/ pip-audit/deptry/import-linter/foundation-check all green.
127 lines
4.2 KiB
Python
127 lines
4.2 KiB
Python
"""The i_am_done conventions gate: block-level violations refuse the submit.
|
|
|
|
With the flag on, a ``block`` finding (or a validator that could not run) on the
|
|
dev's changed files refuses i_am_done with the offending ``file:line`` + a fix
|
|
hint. ``warn`` findings never block; the flag-off path is fully inert.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
from typing import Any
|
|
from unittest.mock import AsyncMock, MagicMock
|
|
|
|
import pytest
|
|
from roboco.config import settings
|
|
from roboco.services.gateway.choreographer import Choreographer, ChoreographerDeps
|
|
|
|
_BLOCK_RESULT: dict[str, Any] = {
|
|
"findings": [
|
|
{
|
|
"file": "app/routers/u.py",
|
|
"line": 2,
|
|
"level": "block",
|
|
"fix_hint": "move it into models/",
|
|
}
|
|
],
|
|
"could_not_run": False,
|
|
}
|
|
|
|
|
|
def _make_choreographer(*, check_result: dict[str, Any]) -> Choreographer:
|
|
base: dict[str, Any] = {
|
|
"task": AsyncMock(),
|
|
"work_session": AsyncMock(),
|
|
"git": AsyncMock(),
|
|
"a2a": AsyncMock(),
|
|
"journal": AsyncMock(),
|
|
"audit": AsyncMock(),
|
|
"evidence_repo": AsyncMock(),
|
|
}
|
|
base["git"].conventions_check_for_task.return_value = check_result
|
|
return Choreographer(ChoreographerDeps(**base))
|
|
|
|
|
|
def _ctx() -> MagicMock:
|
|
ctx = MagicMock()
|
|
ctx.briefing = {}
|
|
return ctx
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_block_finding_refuses_with_location(
|
|
monkeypatch: pytest.MonkeyPatch,
|
|
) -> None:
|
|
monkeypatch.setattr(settings, "conventions_enabled", True)
|
|
c = _make_choreographer(check_result=_BLOCK_RESULT)
|
|
env = await c._conventions_gate(_ctx())
|
|
assert env is not None
|
|
body = env.as_dict()
|
|
assert body["error"] == "invalid_state"
|
|
assert "app/routers/u.py:2" in body["remediate"]
|
|
assert "move it into models/" in body["remediate"]
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_warn_only_does_not_block(monkeypatch: pytest.MonkeyPatch) -> None:
|
|
monkeypatch.setattr(settings, "conventions_enabled", True)
|
|
c = _make_choreographer(
|
|
check_result={
|
|
"findings": [{"file": "x.py", "line": 1, "level": "warn", "fix_hint": "h"}],
|
|
"could_not_run": False,
|
|
}
|
|
)
|
|
assert await c._conventions_gate(_ctx()) is None
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_could_not_run_blocks_loud(monkeypatch: pytest.MonkeyPatch) -> None:
|
|
monkeypatch.setattr(settings, "conventions_enabled", True)
|
|
c = _make_choreographer(check_result={"findings": [], "could_not_run": True})
|
|
env = await c._conventions_gate(_ctx())
|
|
assert env is not None
|
|
assert "could not run" in env.as_dict()["message"]
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_flag_off_is_inert(monkeypatch: pytest.MonkeyPatch) -> None:
|
|
monkeypatch.setattr(settings, "conventions_enabled", False)
|
|
c = _make_choreographer(check_result=_BLOCK_RESULT)
|
|
assert await c._conventions_gate(_ctx()) is None
|
|
|
|
|
|
def test_no_findings_passes() -> None:
|
|
result: dict[str, Any] = {"findings": [], "could_not_run": False}
|
|
assert Choreographer._conventions_rejection(result, {}) is None
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_gate_records_findings_even_when_blocking(
|
|
monkeypatch: pytest.MonkeyPatch,
|
|
) -> None:
|
|
monkeypatch.setattr(settings, "conventions_enabled", True)
|
|
recorded: list[dict[str, Any]] = []
|
|
|
|
async def _spy(_task: Any, result: dict[str, Any]) -> None:
|
|
recorded.append(result)
|
|
|
|
c = _make_choreographer(check_result=_BLOCK_RESULT)
|
|
monkeypatch.setattr(c, "_record_convention_findings", _spy)
|
|
env = await c._conventions_gate(_ctx())
|
|
assert env is not None # still blocks
|
|
assert recorded and recorded[0] is _BLOCK_RESULT
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_gate_never_overrides_the_fail_closed_timeout(
|
|
monkeypatch: pytest.MonkeyPatch,
|
|
) -> None:
|
|
"""i_am_done's conventions gate is fail-closed and must keep the
|
|
validator's hardcoded 120s cap — unlike claim_review's advisory path, it
|
|
must never pass a ``timeout`` override down to ``conventions_check_for_task``."""
|
|
monkeypatch.setattr(settings, "conventions_enabled", True)
|
|
c = _make_choreographer(check_result={"findings": [], "could_not_run": False})
|
|
await c._conventions_gate(_ctx())
|
|
check = c.git.conventions_check_for_task
|
|
check.assert_awaited_once()
|
|
assert "timeout" not in check.await_args.kwargs
|