mirror of
https://github.com/rennf93/roboco.git
synced 2026-08-03 07:23:24 +02:00
bab53e31ca
* perf(panel): kanban virtualization + row memoization + scorecards batch endpoint The audit's remaining phases: the kanban card lists render through @tanstack/react-virtual windows (columns are the dnd drop targets, cards only drag — no sortable conflict) with memoized columns/cards and a stabilized handleAction; the task table's desktop row and mobile card are extracted and memoized (the table itself already client-paginates to 100). Backend: the per-member scorecard N+1 (~20 requests x 3 queries per poll) collapses into GET /dashboard/metrics/members backed by get_all_member_scorecards with grouped rollup/overlay SQL shared with the single-agent path. * test(metrics): shared-DB-safe scorecard tests — unique seeds, delta assertions The two new batch-scorecard tests assumed a private DB: fixed ceo/system slugs collided with other tests' seeds (ix_agents_slug) and a global exactly-one CEO lookup + exact roster count broke in the one-process suite. Unique slugs, subset/disjoint assertions, dead count constant dropped. --------- Co-authored-by: Renn F <rennf93@users.noreply.github.com>
562 lines
17 KiB
Python
562 lines
17 KiB
Python
"""Dashboard API route coverage."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import uuid
|
|
from http import HTTPStatus
|
|
from typing import TYPE_CHECKING, cast
|
|
from uuid import uuid4
|
|
|
|
import pytest
|
|
import pytest_asyncio
|
|
from fastapi import FastAPI
|
|
from httpx import ASGITransport, AsyncClient
|
|
from roboco.api.deps import get_agent_context, get_db
|
|
from roboco.api.routes.dashboard import get_main_pm_kanban
|
|
from roboco.api.routes.dashboard import router as dashboard_router
|
|
from roboco.db.tables import AgentTable, ProjectTable, TaskTable
|
|
from roboco.models import AgentRole, AgentStatus
|
|
from roboco.models.base import (
|
|
Complexity,
|
|
TaskNature,
|
|
TaskStatus,
|
|
TaskType,
|
|
Team,
|
|
)
|
|
from roboco.models.permissions import AgentContext
|
|
from roboco.services.dashboard import reset_storage
|
|
from sqlalchemy import select
|
|
|
|
if TYPE_CHECKING:
|
|
from collections.abc import AsyncGenerator, AsyncIterator
|
|
|
|
from sqlalchemy.ext.asyncio import AsyncSession
|
|
|
|
|
|
@pytest_asyncio.fixture
|
|
async def dashboard_client(
|
|
db_session: AsyncSession,
|
|
) -> AsyncIterator[AsyncClient]:
|
|
reset_storage()
|
|
agent = AgentTable(
|
|
id=uuid4(),
|
|
name="CEO",
|
|
slug=f"ceo-{uuid4().hex[:8]}",
|
|
role=AgentRole.CEO,
|
|
team=None,
|
|
status=AgentStatus.ACTIVE,
|
|
model_config={},
|
|
system_prompt="ceo",
|
|
capabilities=[],
|
|
permissions={},
|
|
metrics={},
|
|
)
|
|
db_session.add(agent)
|
|
await db_session.flush()
|
|
|
|
app = FastAPI()
|
|
app.include_router(dashboard_router, prefix="/api/dashboard")
|
|
|
|
async def _override_db() -> AsyncGenerator[AsyncSession]:
|
|
yield db_session
|
|
|
|
async def _override_agent() -> AgentContext:
|
|
return AgentContext(
|
|
agent_id=cast("uuid.UUID", agent.id), role=AgentRole.CEO, team=None
|
|
)
|
|
|
|
app.dependency_overrides[get_db] = _override_db
|
|
app.dependency_overrides[get_agent_context] = _override_agent
|
|
|
|
transport = ASGITransport(app=app)
|
|
async with AsyncClient(transport=transport, base_url="http://test") as client:
|
|
yield client
|
|
app.dependency_overrides.clear()
|
|
|
|
|
|
_HDR = {"X-Agent-ID": str(uuid4()), "X-Agent-Role": "ceo"}
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_create_auditor_flag(dashboard_client: AsyncClient) -> None:
|
|
response = await dashboard_client.post(
|
|
"/api/dashboard/auditor/flags",
|
|
json={
|
|
"severity": "urgent",
|
|
"category": "quality",
|
|
"title": "Bug found",
|
|
"description": "Critical issue",
|
|
},
|
|
headers=_HDR,
|
|
)
|
|
assert response.status_code == HTTPStatus.CREATED
|
|
body = response.json()
|
|
assert body["severity"] == "urgent"
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_get_auditor_flags(dashboard_client: AsyncClient) -> None:
|
|
response = await dashboard_client.get("/api/dashboard/auditor/flags", headers=_HDR)
|
|
assert response.status_code == HTTPStatus.OK
|
|
assert isinstance(response.json(), list)
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Observability endpoints (0.10.0)
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_cycle_time_endpoint(dashboard_client: AsyncClient) -> None:
|
|
resp = await dashboard_client.get(
|
|
"/api/dashboard/metrics/cycle-time?days=30", headers=_HDR
|
|
)
|
|
assert resp.status_code == HTTPStatus.OK
|
|
assert isinstance(resp.json(), list)
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_bottlenecks_endpoint(dashboard_client: AsyncClient) -> None:
|
|
resp = await dashboard_client.get(
|
|
"/api/dashboard/metrics/bottlenecks", headers=_HDR
|
|
)
|
|
assert resp.status_code == HTTPStatus.OK
|
|
body = resp.json()
|
|
assert "by_stage" in body and "worst_stage" in body and "active_blockers" in body
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_rework_endpoint(dashboard_client: AsyncClient) -> None:
|
|
resp = await dashboard_client.get("/api/dashboard/metrics/rework", headers=_HDR)
|
|
assert resp.status_code == HTTPStatus.OK
|
|
body = resp.json()
|
|
assert "rate" in body and "by_team" in body and "by_agent" in body
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_agent_scorecard_404_when_absent(dashboard_client: AsyncClient) -> None:
|
|
resp = await dashboard_client.get(
|
|
f"/api/dashboard/metrics/scorecard/agent/{uuid4()}", headers=_HDR
|
|
)
|
|
assert resp.status_code == HTTPStatus.NOT_FOUND
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_team_scorecard_endpoint(dashboard_client: AsyncClient) -> None:
|
|
resp = await dashboard_client.get(
|
|
"/api/dashboard/metrics/scorecard/team/backend", headers=_HDR
|
|
)
|
|
assert resp.status_code == HTTPStatus.OK
|
|
assert resp.json()["scope"] == "cell"
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_resolve_auditor_flag(dashboard_client: AsyncClient) -> None:
|
|
create = await dashboard_client.post(
|
|
"/api/dashboard/auditor/flags",
|
|
json={
|
|
"severity": "warning",
|
|
"category": "quality",
|
|
"title": "Warning",
|
|
"description": "x",
|
|
},
|
|
headers=_HDR,
|
|
)
|
|
flag_id = create.json()["id"]
|
|
response = await dashboard_client.put(
|
|
f"/api/dashboard/auditor/flags/{flag_id}/resolve",
|
|
params={"notes": "fixed"},
|
|
headers=_HDR,
|
|
)
|
|
assert response.status_code == HTTPStatus.OK
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_resolve_unknown_flag_returns_404(
|
|
dashboard_client: AsyncClient,
|
|
) -> None:
|
|
response = await dashboard_client.put(
|
|
f"/api/dashboard/auditor/flags/{uuid4()}/resolve", headers=_HDR
|
|
)
|
|
assert response.status_code == HTTPStatus.NOT_FOUND
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_create_auditor_report(dashboard_client: AsyncClient) -> None:
|
|
response = await dashboard_client.post(
|
|
"/api/dashboard/auditor/reports",
|
|
json={
|
|
"report_type": "weekly",
|
|
"title": "Q1 Report",
|
|
"summary": "Strong week",
|
|
"sections": [],
|
|
},
|
|
headers=_HDR,
|
|
)
|
|
assert response.status_code == HTTPStatus.CREATED
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_get_auditor_reports(dashboard_client: AsyncClient) -> None:
|
|
response = await dashboard_client.get(
|
|
"/api/dashboard/auditor/reports", headers=_HDR
|
|
)
|
|
assert response.status_code == HTTPStatus.OK
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_get_kanban_for_team_known_bug(
|
|
dashboard_client: AsyncClient,
|
|
) -> None:
|
|
"""Pre-existing bug — board.team is already a string (not enum) at line 334.
|
|
|
|
The route does `team.value` on a value already coerced to a string,
|
|
raising AttributeError. We assert the bug exists so a fix flips the test.
|
|
"""
|
|
with pytest.raises(AttributeError, match="'str' object has no attribute 'value'"):
|
|
await dashboard_client.get("/api/dashboard/kanban/backend", headers=_HDR)
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_get_all_agent_status(dashboard_client: AsyncClient) -> None:
|
|
response = await dashboard_client.get("/api/dashboard/agents/status", headers=_HDR)
|
|
assert response.status_code == HTTPStatus.OK
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_get_recent_activity(dashboard_client: AsyncClient) -> None:
|
|
response = await dashboard_client.get(
|
|
"/api/dashboard/activity/recent",
|
|
headers=_HDR,
|
|
)
|
|
assert response.status_code == HTTPStatus.OK
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_get_auditor_dashboard(dashboard_client: AsyncClient) -> None:
|
|
response = await dashboard_client.get("/api/dashboard/auditor", headers=_HDR)
|
|
assert response.status_code == HTTPStatus.OK
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_send_auditor_report_not_found(
|
|
dashboard_client: AsyncClient,
|
|
) -> None:
|
|
response = await dashboard_client.post(
|
|
f"/api/dashboard/auditor/reports/{uuid4()}/send", headers=_HDR
|
|
)
|
|
assert response.status_code == HTTPStatus.NOT_FOUND
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_send_auditor_report_success(
|
|
dashboard_client: AsyncClient,
|
|
) -> None:
|
|
create = await dashboard_client.post(
|
|
"/api/dashboard/auditor/reports",
|
|
json={
|
|
"report_type": "weekly",
|
|
"title": "T",
|
|
"summary": "s",
|
|
"sections": [],
|
|
},
|
|
headers=_HDR,
|
|
)
|
|
rid = create.json()["id"]
|
|
response = await dashboard_client.post(
|
|
f"/api/dashboard/auditor/reports/{rid}/send", headers=_HDR
|
|
)
|
|
assert response.status_code == HTTPStatus.OK
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_get_ceo_overview(dashboard_client: AsyncClient) -> None:
|
|
response = await dashboard_client.get("/api/dashboard/ceo", headers=_HDR)
|
|
assert response.status_code == HTTPStatus.OK
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_get_ceo_team_details(dashboard_client: AsyncClient) -> None:
|
|
response = await dashboard_client.get("/api/dashboard/ceo/teams", headers=_HDR)
|
|
assert response.status_code == HTTPStatus.OK
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_get_ceo_blocker_details(dashboard_client: AsyncClient) -> None:
|
|
response = await dashboard_client.get("/api/dashboard/ceo/blockers", headers=_HDR)
|
|
assert response.status_code == HTTPStatus.OK
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_get_ceo_velocity(dashboard_client: AsyncClient) -> None:
|
|
response = await dashboard_client.get(
|
|
"/api/dashboard/ceo/velocity?days=14", headers=_HDR
|
|
)
|
|
assert response.status_code == HTTPStatus.OK
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_get_main_pm_kanban_via_http(dashboard_client: AsyncClient) -> None:
|
|
"""`/kanban/main-pm` is now declared before `/kanban/{team}`, so it routes
|
|
correctly to `get_main_pm_kanban` instead of being matched as
|
|
`team=main-pm` (which would 422)."""
|
|
response = await dashboard_client.get("/api/dashboard/kanban/main-pm", headers=_HDR)
|
|
assert response.status_code == HTTPStatus.OK
|
|
body = response.json()
|
|
# main_pm board has columns; shape is from KanbanBoard.model_dump().
|
|
assert "columns" in body
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_get_velocity_metrics(dashboard_client: AsyncClient) -> None:
|
|
response = await dashboard_client.get(
|
|
"/api/dashboard/metrics/velocity?days=7", headers=_HDR
|
|
)
|
|
assert response.status_code == HTTPStatus.OK
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_get_blocker_metrics(dashboard_client: AsyncClient) -> None:
|
|
response = await dashboard_client.get(
|
|
"/api/dashboard/metrics/blockers", headers=_HDR
|
|
)
|
|
assert response.status_code == HTTPStatus.OK
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_get_team_metrics(dashboard_client: AsyncClient) -> None:
|
|
response = await dashboard_client.get(
|
|
"/api/dashboard/metrics/team/backend", headers=_HDR
|
|
)
|
|
assert response.status_code == HTTPStatus.OK
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_get_health_metrics(dashboard_client: AsyncClient) -> None:
|
|
response = await dashboard_client.get("/api/dashboard/metrics/health", headers=_HDR)
|
|
assert response.status_code == HTTPStatus.OK
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_get_agent_metrics_not_found(
|
|
dashboard_client: AsyncClient,
|
|
) -> None:
|
|
response = await dashboard_client.get(
|
|
f"/api/dashboard/metrics/agent/{uuid4()}", headers=_HDR
|
|
)
|
|
assert response.status_code == HTTPStatus.NOT_FOUND
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_get_auditor_flags_filter_severity(
|
|
dashboard_client: AsyncClient,
|
|
) -> None:
|
|
response = await dashboard_client.get(
|
|
"/api/dashboard/auditor/flags?severity=warning", headers=_HDR
|
|
)
|
|
assert response.status_code == HTTPStatus.OK
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_get_auditor_reports_with_filter(
|
|
dashboard_client: AsyncClient,
|
|
) -> None:
|
|
response = await dashboard_client.get(
|
|
"/api/dashboard/auditor/reports?report_type=weekly", headers=_HDR
|
|
)
|
|
assert response.status_code == HTTPStatus.OK
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_get_agent_metrics_existing_agent(
|
|
dashboard_client: AsyncClient,
|
|
db_session: AsyncSession,
|
|
) -> None:
|
|
"""Existing agent → exercise route happy path (line 494)."""
|
|
agent = AgentTable(
|
|
id=uuid4(),
|
|
name="Probe",
|
|
slug=f"probe-{uuid4().hex[:8]}",
|
|
role=AgentRole.DEVELOPER,
|
|
team=None,
|
|
status=AgentStatus.ACTIVE,
|
|
model_config={},
|
|
system_prompt="x",
|
|
capabilities=[],
|
|
permissions={},
|
|
metrics={},
|
|
)
|
|
db_session.add(agent)
|
|
await db_session.flush()
|
|
response = await dashboard_client.get(
|
|
f"/api/dashboard/metrics/agent/{agent.id}", headers=_HDR
|
|
)
|
|
# MetricsService may return None for an empty agent → 404; or a metrics
|
|
# object if there's enough data. Either way the route is exercised.
|
|
assert response.status_code in (HTTPStatus.OK, HTTPStatus.NOT_FOUND)
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_get_main_pm_kanban_function_directly(
|
|
db_session: AsyncSession,
|
|
) -> None:
|
|
"""Route /kanban/main-pm is unreachable via HTTP (intercepted by /kanban/{team}).
|
|
|
|
Call the route function directly to cover lines 367-369.
|
|
"""
|
|
result = await get_main_pm_kanban(db_session)
|
|
assert isinstance(result, dict)
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_ceo_scorecard_endpoint(dashboard_client: AsyncClient) -> None:
|
|
resp = await dashboard_client.get(
|
|
"/api/dashboard/metrics/member/ceo?days=30", headers=_HDR
|
|
)
|
|
assert resp.status_code == HTTPStatus.OK
|
|
body = resp.json()
|
|
assert body["member_kind"] == "ceo"
|
|
assert set(body) >= {
|
|
"approval_p50_seconds",
|
|
"approval_count",
|
|
"unblock_p50_seconds",
|
|
"unblock_count",
|
|
"godmode_actions",
|
|
}
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_member_scorecard_404_when_absent(dashboard_client: AsyncClient) -> None:
|
|
resp = await dashboard_client.get(
|
|
f"/api/dashboard/metrics/member/{uuid4()}", headers=_HDR
|
|
)
|
|
assert resp.status_code == HTTPStatus.NOT_FOUND
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_ceo_route_wins_over_member_uuid_route(
|
|
dashboard_client: AsyncClient,
|
|
) -> None:
|
|
# The literal "ceo" must resolve to the CEO route, not the {agent_id} route.
|
|
resp = await dashboard_client.get("/api/dashboard/metrics/member/ceo", headers=_HDR)
|
|
assert resp.status_code == HTTPStatus.OK
|
|
assert resp.json()["member_kind"] == "ceo"
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_org_scorecard_endpoint(dashboard_client: AsyncClient) -> None:
|
|
resp = await dashboard_client.get("/api/dashboard/metrics/org", headers=_HDR)
|
|
assert resp.status_code == HTTPStatus.OK
|
|
body = resp.json()
|
|
assert body["scope"] == "org"
|
|
assert set(body) >= {"member_count", "tasks_completed", "first_pass_yield"}
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_all_member_scorecards_endpoint(
|
|
dashboard_client: AsyncClient, db_session: AsyncSession
|
|
) -> None:
|
|
"""The batch scorecard route (N+1 fix) returns one MemberScorecard per
|
|
non-CEO/non-system agent — the CEO seeded by the fixture is excluded."""
|
|
dev = AgentTable(
|
|
id=uuid4(),
|
|
name="be-dev-1",
|
|
slug=f"be-dev-{uuid4().hex[:8]}",
|
|
role=AgentRole.DEVELOPER,
|
|
team=Team.BACKEND,
|
|
status=AgentStatus.ACTIVE,
|
|
model_config={},
|
|
system_prompt="dev",
|
|
capabilities=[],
|
|
permissions={},
|
|
metrics={},
|
|
)
|
|
db_session.add(dev)
|
|
await db_session.flush()
|
|
|
|
resp = await dashboard_client.get("/api/dashboard/metrics/members", headers=_HDR)
|
|
assert resp.status_code == HTTPStatus.OK
|
|
body = resp.json()
|
|
assert isinstance(body, list)
|
|
ids = {card["id"] for card in body}
|
|
assert str(dev.id) in ids
|
|
# The shared per-run DB can hold several CEO rows (other tests seed
|
|
# their own); every one of them must be excluded from the batch.
|
|
ceo_ids = (
|
|
(
|
|
await db_session.execute(
|
|
select(AgentTable.id).where(AgentTable.role == AgentRole.CEO)
|
|
)
|
|
)
|
|
.scalars()
|
|
.all()
|
|
)
|
|
assert ceo_ids
|
|
assert ids.isdisjoint({str(cid) for cid in ceo_ids})
|
|
for card in body:
|
|
assert card["scope"] == "member"
|
|
assert card["member_kind"] == "agent"
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_task_metrics_404_for_missing_task(
|
|
dashboard_client: AsyncClient,
|
|
) -> None:
|
|
resp = await dashboard_client.get(
|
|
f"/api/dashboard/metrics/task/{uuid4()}", headers=_HDR
|
|
)
|
|
assert resp.status_code == HTTPStatus.NOT_FOUND
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_task_metrics_returns_shape_for_existing_task(
|
|
db_session: AsyncSession, dashboard_client: AsyncClient
|
|
) -> None:
|
|
creator = (await db_session.execute(select(AgentTable).limit(1))).scalar_one()
|
|
project = ProjectTable(
|
|
id=uuid4(),
|
|
name="P",
|
|
slug=f"p-{uuid4().hex[:6]}",
|
|
git_url="https://example.com/r.git",
|
|
assigned_cell=Team.BACKEND,
|
|
created_by=creator.id,
|
|
)
|
|
db_session.add(project)
|
|
await db_session.flush()
|
|
task = TaskTable(
|
|
id=uuid4(),
|
|
title="t",
|
|
description="d",
|
|
acceptance_criteria=["ac"],
|
|
task_type=TaskType.CODE,
|
|
nature=TaskNature.TECHNICAL,
|
|
status=TaskStatus.IN_PROGRESS,
|
|
team=Team.BACKEND,
|
|
project_id=project.id,
|
|
created_by=creator.id,
|
|
estimated_complexity=Complexity.MEDIUM,
|
|
)
|
|
db_session.add(task)
|
|
await db_session.flush()
|
|
|
|
resp = await dashboard_client.get(
|
|
f"/api/dashboard/metrics/task/{task.id}", headers=_HDR
|
|
)
|
|
assert resp.status_code == HTTPStatus.OK
|
|
body = resp.json()
|
|
assert body["task_id"] == str(task.id)
|
|
assert set(body) >= {
|
|
"active_runtime_seconds",
|
|
"wall_clock_seconds",
|
|
"turns",
|
|
"tool_calls",
|
|
"tokens",
|
|
"cost_usd",
|
|
"revision_count",
|
|
"qa_fails",
|
|
"pr_fails",
|
|
"stints",
|
|
"stages",
|
|
}
|
|
assert isinstance(body["stages"], list)
|