External/roboco
1
0
Fork 0
mirror of https://github.com/rennf93/roboco.git synced 2026-08-03 07:23:24 +02:00
Code Issues Packages Projects Releases Wiki Activity
Files
4829f93a680b420d49cb7e83073387f8e5b269be
roboco/tests/unit/gateway/test_content_actions.py
T
Renn F 4829f93a68 fix(gateway): unblock task claim; full Phase 0/1/2 remediation 
Resolves the 100% claim-failure rate introduced by the gateway rewrite
  (commit 62bda0c plus 78 follow-ups). Live smoke runs hit
  `404 /api/v2/flow/developer/...` on every dev verb plus a manifest
  fallback that silently exposed off-role verbs to PMs — confirmed
  firing simultaneously in NAS agent logs (be-dev-1, be-pm, main-pm).

  Audit reports under docs/internal/audit_2026_05_04/ catalogue 49
  defects across gateway, services, prompts, MCP transport, substrate,
  and tests (8 detail reports + master synthesis). Six smoking guns;
  three proven in production logs.

  Phase 0 — unblock claim:
  - URL prefix /api/v2/flow/dev → /developer; slug-map board roles
    (product_owner, head_marketing) → /board (D-01)
  - _i_will_work_on AttributeError on None across pending /
    needs_revision / claimed re-entry branches (D-02)
  - Seed last_heartbeat_at in _qa_or_doc_claim (D-03)
  - Drop misleading i_have_committed verb; dev flow uses commit() (D-04)
  - Manifest mount via compose; flow_server + do_server fail loud
    instead of exposing all-verbs fallback (D-12)
  - MCP _post() surfaces envelope body on 4xx so agents see remediate
    hints (D-13)
    on git failure so retries aren't blocked by half-state (S-01)

  Phase 1 — lifecycle stability:
  - _resolve_skill falls back to AgentTable.capabilities (D-06)
  - main_pm_complete uses kwargs for escalate_to_ceo (D-07)
  - i_am_done auto-runs submit_verification when in_progress (D-08)
  - active_claimant_id wired in claim/unclaim paths — single-claimant
    invariant now functional (D-05)
  - qa_pass/qa_fail assert claimed_by parity with qa_agent_id (D-18)
  - Prompt-drift sweep: fail() shape, i_am_done(task_id, notes),
    subtask cap (12 hard / 8 soft), error-code symbology rewritten in
    base.md + per-role anti-patterns (D-10/11/29/30/31, D-37)

  Phase 2 — invariants + architecture:
  - Real-DB integration test exercising claim → in_progress → commit
    → submit_for_qa → i_am_done → awaiting_qa (P2-1)
  - choreographer.py → package; 3 of 6 role mixins extracted
    (board, doc, qa). _impl.py 2,526 → 2,080 lines (-18%). Continuation
    plan in docs/internal/audit_2026_05_04/p2_2_decompose_plan.md (P2-2)
  - Closure guards consolidated via _subtasks_not_terminal_envelope (P2-3)
  - TaskService.unclaim_for_reaper routed through canonical
    _validate_and_set_status; in_progress → pending added to
    VALID_TRANSITIONS (P2-4)
  - Dead code removed: i_am_done_with_catchup verb, _run_catch_up helper
    (P2-5)
  - 6 state-machine invariants asserted via property test (P2-6)
  - attempt_id (uuid4) stamped on every gateway.rejected audit row (P2-7)
  - _reconcile_orphan_claims_on_startup rolls back tasks left CLAIMED
    with branch_name=NULL from prior crashes (P2-8)
  - scripts/regenerate_verb_tables.py introspects Pydantic schemas +
    role_config; compose_prompt injects per-role tables as a layer.
    Eliminates the prompt-drift class structurally (P2-9)

  Other:
  - D-48: orchestrator mounts host's ~/.claude.json when present so
    agents don't boot from backup recovery on every spawn
  - D-49: dev dispatcher rejects role-mismatched spawns (e.g. doc task
    assigned to dev agent)

  Tests: 553 pass · ruff + mypy clean. Live NAS smoke verification
  pending — needs the stack brought back up.
2026-05-04 23:43:55 +02:00

457 lines
15 KiB
Python
Raw Blame History

"""Tests for ContentActions — commit, note, say, dm, evidence verbs."""
from __future__ import annotations
from unittest.mock import AsyncMock, MagicMock
from uuid import uuid4
import pytest
from roboco.services.gateway.content_actions import ContentActions, ContentActionsDeps
def _make_deps(**overrides: AsyncMock) -> ContentActionsDeps:
# Only set default return values on freshly-created mocks,
# not on caller-supplied ones.
if "task" in overrides:
task = overrides["task"]
else:
task = AsyncMock()
task.get_active_task_for_agent.return_value = None
# commit() checks caller role server-side; default-created mocks
# need a default developer role so existing tests pass through.
# Caller-supplied mocks must set agent_for themselves.
task.agent_for.return_value = MagicMock(role="developer")
if "git" in overrides:
git = overrides["git"]
else:
git = AsyncMock()
git.commit.return_value = {"sha": "abc12345"}
git.diff.return_value = ""
messaging = overrides.get("messaging", AsyncMock())
a2a = overrides.get("a2a", AsyncMock())
journal = overrides.get("journal", AsyncMock())
workspace = overrides.get("workspace", AsyncMock())
notifications = overrides.get("notifications", AsyncMock())
return ContentActionsDeps(
task=task,
git=git,
messaging=messaging,
a2a=a2a,
journal=journal,
workspace=workspace,
notifications=notifications,
)
# ---------------------------------------------------------------------------
# commit
# ---------------------------------------------------------------------------
@pytest.mark.asyncio
async def test_commit_wip_is_rejected() -> None:
"""Short banned word "wip" fails commit validator before task lookup."""
deps = _make_deps()
ca = ContentActions(deps)
agent_id = uuid4()
env = await ca.commit(agent_id=agent_id, message="wip")
body = env.as_dict()
assert body["error"] == "invalid_state"
deps.task.get_active_task_for_agent.assert_not_awaited()
@pytest.mark.asyncio
async def test_commit_descriptive_with_active_task_succeeds() -> None:
"""Descriptive subject succeeds; calls git.commit and task.add_progress."""
agent_id = uuid4()
task_id = uuid4()
task_obj = MagicMock(
id=task_id, status="in_progress", branch_name="feature/backend/abc"
)
task_svc = AsyncMock()
task_svc.get_active_task_for_agent.return_value = task_obj
task_svc.agent_for.return_value = MagicMock(role="developer")
git_svc = AsyncMock()
git_svc.commit.return_value = {"sha": "deadbeef1234"}
deps = _make_deps(task=task_svc, git=git_svc)
ca = ContentActions(deps)
env = await ca.commit(
agent_id=agent_id,
message="feat(api): add /healthz endpoint for liveness checks",
)
body = env.as_dict()
assert body["error"] is None
assert body["task_id"] == str(task_id)
git_svc.commit.assert_awaited_once()
task_svc.add_progress.assert_awaited_once()
# Progress message contains short sha
call_args = task_svc.add_progress.call_args
assert "deadbeef" in call_args.args[2]
@pytest.mark.asyncio
async def test_commit_no_active_task_returns_invalid_state() -> None:
"""Valid message but no active task → invalid_state."""
deps = _make_deps()
ca = ContentActions(deps)
agent_id = uuid4()
env = await ca.commit(
agent_id=agent_id,
message="feat(auth): implement JWT refresh token rotation logic",
)
body = env.as_dict()
assert body["error"] == "invalid_state"
assert "give_me_work" in body["remediate"]
deps.git.commit.assert_not_awaited()
@pytest.mark.asyncio
async def test_commit_strips_existing_task_prefix() -> None:
"""Agent-supplied [task-id] prefix is stripped before validation;
the canonical [task-id-short] is re-applied before git.commit."""
agent_id = uuid4()
task_id = uuid4()
expected_prefix = f"[{str(task_id)[:8]}]"
task_obj = MagicMock(
id=task_id, status="in_progress", branch_name="feature/backend/abc"
)
task_svc = AsyncMock()
task_svc.get_active_task_for_agent.return_value = task_obj
task_svc.agent_for.return_value = MagicMock(role="developer")
git_svc = AsyncMock()
git_svc.commit.return_value = {"sha": "cafebabe"}
deps = _make_deps(task=task_svc, git=git_svc)
ca = ContentActions(deps)
env = await ca.commit(
agent_id=agent_id,
message="[ABC12345] feat(api): add rate limiting middleware to all routes",
)
body = env.as_dict()
assert body["error"] is None
# The subject passed to git.commit gets the canonical prefix re-applied,
# not the user-supplied [ABC12345].
call_kwargs = git_svc.commit.call_args.kwargs
assert call_kwargs["message"].startswith(expected_prefix)
assert "[ABC12345]" not in call_kwargs["message"]
# ---------------------------------------------------------------------------
# note
# ---------------------------------------------------------------------------
@pytest.mark.asyncio
async def test_commit_rejects_pm_role() -> None:
"""Regression: PMs must not be able to call commit (smoke 2026-05-03)."""
agent_id = uuid4()
task_svc = AsyncMock()
task_svc.agent_for.return_value = MagicMock(role="main_pm")
deps = _make_deps(task=task_svc)
ca = ContentActions(deps)
env = await ca.commit(agent_id=agent_id, message="fix: something")
body = env.as_dict()
assert body["error"] == "not_authorized"
assert "main_pm" in body["message"]
assert "delegate" in body["remediate"]
@pytest.mark.asyncio
async def test_commit_rejects_qa_role() -> None:
"""QA cannot author commits — only developers and documenters can."""
agent_id = uuid4()
task_svc = AsyncMock()
task_svc.agent_for.return_value = MagicMock(role="qa")
deps = _make_deps(task=task_svc)
ca = ContentActions(deps)
env = await ca.commit(agent_id=agent_id, message="fix: bug")
assert env.as_dict()["error"] == "not_authorized"
@pytest.mark.asyncio
async def test_commit_rejects_board_role() -> None:
"""Board members do not write code."""
agent_id = uuid4()
task_svc = AsyncMock()
task_svc.agent_for.return_value = MagicMock(role="product_owner")
deps = _make_deps(task=task_svc)
ca = ContentActions(deps)
env = await ca.commit(agent_id=agent_id, message="fix: thing")
assert env.as_dict()["error"] == "not_authorized"
@pytest.mark.asyncio
async def test_commit_allows_documenter_role() -> None:
"""Documenters write doc commits — must not be rejected."""
agent_id = uuid4()
task_id = uuid4()
task_obj = MagicMock(
id=task_id, status="awaiting_documentation", branch_name="feature/backend/abc"
)
task_svc = AsyncMock()
task_svc.agent_for.return_value = MagicMock(role="documenter")
task_svc.get_active_task_for_agent.return_value = task_obj
git_svc = AsyncMock()
git_svc.commit.return_value = {"sha": "deadbeef"}
deps = _make_deps(task=task_svc, git=git_svc)
ca = ContentActions(deps)
env = await ca.commit(agent_id=agent_id, message="docs: add migration notes")
assert env.error is None # not rejected on role grounds
@pytest.mark.asyncio
async def test_note_reflect_scope_succeeds() -> None:
"""scope='reflect' is valid; journal.write_entry is called."""
agent_id = uuid4()
task_id = uuid4()
task_svc = AsyncMock()
task_svc.get_active_task_for_agent.return_value = None
# When task_id is explicit, ownership is verified — agent must be assignee.
task_svc.get.return_value = MagicMock(
id=task_id, assigned_to=agent_id, status="in_progress"
)
journal_svc = AsyncMock()
deps = _make_deps(task=task_svc, journal=journal_svc)
ca = ContentActions(deps)
env = await ca.note(
agent_id=agent_id,
text="Reflected on approach: went with async generator pattern.",
scope="reflect",
task_id=task_id,
)
body = env.as_dict()
assert body["error"] is None
assert body["status"] == "noted"
journal_svc.write_entry.assert_awaited_once()
call_kwargs = journal_svc.write_entry.call_args.kwargs
assert call_kwargs["scope"] == "reflect"
@pytest.mark.asyncio
async def test_note_invalid_scope_returns_invalid_state() -> None:
"""Unknown scope yields invalid_state with valid-scope hint."""
deps = _make_deps()
ca = ContentActions(deps)
agent_id = uuid4()
env = await ca.note(agent_id=agent_id, text="some text", scope="garbage")
body = env.as_dict()
assert body["error"] == "invalid_state"
assert "garbage" in body["message"]
assert "note" in body["remediate"]
deps.journal.write_entry.assert_not_awaited()
@pytest.mark.asyncio
async def test_note_auto_fills_task_id_from_active_task() -> None:
"""When no task_id given but agent has active task, it is auto-filled."""
agent_id = uuid4()
task_id = uuid4()
task_obj = MagicMock(id=task_id, status="in_progress")
task_svc = AsyncMock()
task_svc.get_active_task_for_agent.return_value = task_obj
journal_svc = AsyncMock()
deps = _make_deps(task=task_svc, journal=journal_svc)
ca = ContentActions(deps)
env = await ca.note(
agent_id=agent_id,
text="Decided to use UUIDs instead of integer PKs for portability.",
scope="decision",
)
body = env.as_dict()
assert body["error"] is None
assert body["task_id"] == str(task_id)
call_kwargs = journal_svc.write_entry.call_args.kwargs
assert call_kwargs["task_id"] == task_id
# ---------------------------------------------------------------------------
# say
# ---------------------------------------------------------------------------
@pytest.mark.asyncio
async def test_say_auto_injects_task_id_when_active_task_exists() -> None:
"""Channel post auto-injects task_id from active task."""
agent_id = uuid4()
task_id = uuid4()
task_obj = MagicMock(id=task_id, status="in_progress")
task_svc = AsyncMock()
task_svc.get_active_task_for_agent.return_value = task_obj
messaging_svc = AsyncMock()
deps = _make_deps(task=task_svc, messaging=messaging_svc)
ca = ContentActions(deps)
env = await ca.say(
agent_id=agent_id, channel="backend-cell", text="Starting the auth refactor."
)
body = env.as_dict()
assert body["error"] is None
assert body["task_id"] == str(task_id)
call_kwargs = messaging_svc.post_to_channel.call_args.kwargs
assert call_kwargs["task_id"] == task_id
@pytest.mark.asyncio
async def test_say_succeeds_with_no_active_task_task_id_is_null() -> None:
"""say without active task still succeeds; task_id in response is None."""
deps = _make_deps()
ca = ContentActions(deps)
agent_id = uuid4()
env = await ca.say(
agent_id=agent_id,
channel="all-hands",
text="Hello team, I am about to start work.",
)
body = env.as_dict()
assert body["error"] is None
assert body["task_id"] is None
deps.messaging.post_to_channel.assert_awaited_once()
# ---------------------------------------------------------------------------
# dm
# ---------------------------------------------------------------------------
@pytest.mark.asyncio
async def test_dm_no_active_task_no_explicit_task_id_returns_invalid_state() -> None:
"""dm without any task context is rejected with a clear error."""
deps = _make_deps()
ca = ContentActions(deps)
agent_id = uuid4()
env = await ca.dm(
agent_id=agent_id,
recipient="be-qa-1",
text="Can you review this when you have a moment?",
)
body = env.as_dict()
assert body["error"] == "invalid_state"
assert "task_id" in body["message"]
deps.a2a.send.assert_not_awaited()
@pytest.mark.asyncio
async def test_dm_with_active_task_succeeds() -> None:
"""dm auto-injects task_id from active task and sends."""
agent_id = uuid4()
task_id = uuid4()
task_obj = MagicMock(id=task_id, status="in_progress")
task_svc = AsyncMock()
task_svc.get_active_task_for_agent.return_value = task_obj
a2a_svc = AsyncMock()
deps = _make_deps(task=task_svc, a2a=a2a_svc)
ca = ContentActions(deps)
env = await ca.dm(
agent_id=agent_id,
recipient="be-qa-1",
text="PR is ready for review.",
skill="code_review",
)
body = env.as_dict()
assert body["error"] is None
assert body["task_id"] == str(task_id)
a2a_svc.send.assert_awaited_once()
call_kwargs = a2a_svc.send.call_args.kwargs
assert call_kwargs["to_agent"] == "be-qa-1"
assert call_kwargs["skill"] == "code_review"
# ---------------------------------------------------------------------------
# evidence
# ---------------------------------------------------------------------------
@pytest.mark.asyncio
async def test_evidence_valid_task_returns_ok_with_pr_diff() -> None:
"""evidence() fetches branch, builds diff, returns EvidencePayload."""
agent_id = uuid4()
task_id = uuid4()
ws_id = uuid4()
pr_number = 42
task_obj = MagicMock(
id=task_id,
status="awaiting_qa",
# assigned_to=None covers post-handoff inspection (QA reviewing dev work)
assigned_to=None,
branch_name="feature/backend/abc",
work_session_id=ws_id,
commits=["sha1"],
pr_number=pr_number,
pr_url=f"https://github.com/org/repo/pull/{pr_number}",
dev_notes="done",
acceptance_criteria_status=[],
)
task_svc = AsyncMock()
task_svc.get.return_value = task_obj
git_svc = AsyncMock()
git_svc.diff.return_value = "diff --git a/foo.py b/foo.py\n+added line"
workspace_svc = AsyncMock()
deps = _make_deps(task=task_svc, git=git_svc, workspace=workspace_svc)
ca = ContentActions(deps)
env = await ca.evidence(agent_id=agent_id, task_id=task_id)
body = env.as_dict()
assert body["error"] is None
assert body["task_id"] == str(task_id)
assert body["evidence"]["pr_number"] == pr_number
assert "diff --git" in body["evidence"]["pr_diff_summary"]
workspace_svc.fetch_branch_for_inspection.assert_awaited_once()
git_svc.diff.assert_awaited_once()
@pytest.mark.asyncio
async def test_evidence_task_not_found_returns_not_found() -> None:
"""evidence() returns not_found when task does not exist."""
task_svc = AsyncMock()
task_svc.get.return_value = None
deps = _make_deps(task=task_svc)
ca = ContentActions(deps)
agent_id = uuid4()
task_id = uuid4()
env = await ca.evidence(agent_id=agent_id, task_id=task_id)
body = env.as_dict()
assert body["error"] == "not_found"
assert str(task_id) in body["message"]
Reference in New Issue View Git Blame Copy Permalink