mirror of
https://github.com/rennf93/roboco.git
synced 2026-08-03 07:23:24 +02:00
511 lines
15 KiB
Python
511 lines
15 KiB
Python
"""Channels API route coverage."""
|
|
|
|
from __future__ import annotations
|
|
|
|
from http import HTTPStatus
|
|
from types import SimpleNamespace
|
|
from typing import TYPE_CHECKING
|
|
from unittest.mock import patch
|
|
from uuid import uuid4
|
|
from uuid import uuid4 as _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.channels import router as channels_router
|
|
from roboco.db.tables import AgentTable, ChannelTable, GroupTable
|
|
from roboco.models import AgentRole, AgentStatus, Team
|
|
from roboco.models.base import ChannelType
|
|
from roboco.models.base import ChannelType as _CT
|
|
from roboco.models.messaging import ChannelCreateRequest as _CR
|
|
from roboco.models.permissions import AgentContext
|
|
from roboco.services.messaging import get_messaging_service
|
|
|
|
if TYPE_CHECKING:
|
|
from collections.abc import AsyncIterator
|
|
|
|
from sqlalchemy.ext.asyncio import AsyncSession
|
|
|
|
|
|
@pytest_asyncio.fixture
|
|
async def channels_client(
|
|
db_session: AsyncSession,
|
|
) -> AsyncIterator[dict]:
|
|
main_pm = AgentTable(
|
|
id=uuid4(),
|
|
name="MainPM",
|
|
slug=f"main-pm-{uuid4().hex[:8]}",
|
|
role=AgentRole.MAIN_PM,
|
|
team=None,
|
|
status=AgentStatus.ACTIVE,
|
|
model_config={},
|
|
system_prompt="pm",
|
|
capabilities=[],
|
|
permissions={},
|
|
metrics={},
|
|
)
|
|
db_session.add(main_pm)
|
|
await db_session.flush()
|
|
|
|
channel = ChannelTable(
|
|
id=uuid4(),
|
|
name="ch",
|
|
slug=f"ch-{uuid4().hex[:6]}",
|
|
type=ChannelType.CELL,
|
|
)
|
|
db_session.add(channel)
|
|
await db_session.flush()
|
|
|
|
app = FastAPI()
|
|
app.include_router(channels_router, prefix="/api/channels")
|
|
|
|
async def _override_db():
|
|
yield db_session
|
|
|
|
async def _override_agent() -> AgentContext:
|
|
return AgentContext(agent_id=main_pm.id, role=AgentRole.MAIN_PM, 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": client, "channel": channel, "pm": main_pm}
|
|
app.dependency_overrides.clear()
|
|
|
|
|
|
_HDR = {"X-Agent-ID": str(uuid4()), "X-Agent-Role": "main_pm"}
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_list_channels(channels_client: dict) -> None:
|
|
client = channels_client["client"]
|
|
response = await client.get("/api/channels", headers=_HDR)
|
|
assert response.status_code == HTTPStatus.OK
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_get_channel_unknown(channels_client: dict) -> None:
|
|
client = channels_client["client"]
|
|
response = await client.get(f"/api/channels/{uuid4()}", headers=_HDR)
|
|
assert response.status_code == HTTPStatus.NOT_FOUND
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_list_channels_filter_by_slug(channels_client: dict) -> None:
|
|
client = channels_client["client"]
|
|
response = await client.get(
|
|
f"/api/channels?slug={channels_client['channel'].slug}", headers=_HDR
|
|
)
|
|
assert response.status_code == HTTPStatus.OK
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_get_channel_by_id(channels_client: dict) -> None:
|
|
client = channels_client["client"]
|
|
response = await client.get(
|
|
f"/api/channels/{channels_client['channel'].id}", headers=_HDR
|
|
)
|
|
# Channel may or may not be in agent's accessible list — return some valid status.
|
|
assert response.status_code in (
|
|
HTTPStatus.OK,
|
|
HTTPStatus.FORBIDDEN,
|
|
HTTPStatus.NOT_FOUND,
|
|
)
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_get_channel_groups_unknown(channels_client: dict) -> None:
|
|
client = channels_client["client"]
|
|
response = await client.get(f"/api/channels/{uuid4()}/groups", headers=_HDR)
|
|
assert response.status_code == HTTPStatus.NOT_FOUND
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_create_channel_dev_forbidden(db_session: AsyncSession) -> None:
|
|
"""Developer can't create channels."""
|
|
dev = AgentTable(
|
|
id=uuid4(),
|
|
name="Dev",
|
|
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()
|
|
|
|
app = FastAPI()
|
|
app.include_router(channels_router, prefix="/api/channels")
|
|
|
|
async def _override_db():
|
|
yield db_session
|
|
|
|
async def _override_agent() -> AgentContext:
|
|
return AgentContext(
|
|
agent_id=dev.id, role=AgentRole.DEVELOPER, team=Team.BACKEND
|
|
)
|
|
|
|
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:
|
|
response = await client.post(
|
|
"/api/channels",
|
|
json={
|
|
"name": "ch",
|
|
"slug": f"ch-{uuid4().hex[:6]}",
|
|
"type": "cell",
|
|
"members": [],
|
|
},
|
|
headers=_HDR,
|
|
)
|
|
app.dependency_overrides.clear()
|
|
assert response.status_code == HTTPStatus.FORBIDDEN
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_create_channel_known_service_bug(channels_client: dict) -> None:
|
|
"""Pre-existing bug in MessagingService — accesses .value on str.
|
|
|
|
When the service raises AttributeError, the route layer is reached, but
|
|
a downstream regression in `messaging.create_channel` raises uncaught.
|
|
We document this — once fixed elsewhere, this test will need flipping.
|
|
"""
|
|
client = channels_client["client"]
|
|
with pytest.raises(AttributeError, match="'str' object has no attribute 'value'"):
|
|
await client.post(
|
|
"/api/channels",
|
|
json={
|
|
"name": "ch",
|
|
"slug": f"ch-{uuid4().hex[:6]}",
|
|
"type": "cell",
|
|
"members": [],
|
|
"writers": [],
|
|
"silent_observers": [],
|
|
"is_private": False,
|
|
},
|
|
headers=_HDR,
|
|
)
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_create_channel_success_returns_response(channels_client: dict) -> None:
|
|
"""Line 218: success path returns ChannelResponse via service mock."""
|
|
|
|
fake_channel = SimpleNamespace(
|
|
id=_uuid4(),
|
|
name="test-ch",
|
|
slug="test-ch",
|
|
type=ChannelType.CELL,
|
|
description=None,
|
|
topic=None,
|
|
is_private=False,
|
|
members=[],
|
|
writers=[],
|
|
silent_observers=[],
|
|
)
|
|
|
|
client = channels_client["client"]
|
|
with patch(
|
|
"roboco.services.messaging.MessagingService.create_channel",
|
|
return_value=fake_channel,
|
|
):
|
|
response = await client.post(
|
|
"/api/channels",
|
|
json={
|
|
"name": "test-ch",
|
|
"slug": "test-ch",
|
|
"type": "cell",
|
|
"members": [],
|
|
"writers": [],
|
|
"silent_observers": [],
|
|
"is_private": False,
|
|
},
|
|
headers=_HDR,
|
|
)
|
|
assert response.status_code in (HTTPStatus.CREATED, HTTPStatus.OK)
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_update_channel_unknown(channels_client: dict) -> None:
|
|
client = channels_client["client"]
|
|
response = await client.patch(
|
|
f"/api/channels/{uuid4()}",
|
|
json={"description": "new desc"},
|
|
headers=_HDR,
|
|
)
|
|
# 404 or schema may reject
|
|
assert response.status_code in (
|
|
HTTPStatus.NOT_FOUND,
|
|
HTTPStatus.UNPROCESSABLE_ENTITY,
|
|
)
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_add_member_unknown_channel(channels_client: dict) -> None:
|
|
client = channels_client["client"]
|
|
response = await client.post(
|
|
f"/api/channels/{uuid4()}/members/{uuid4()}", headers=_HDR
|
|
)
|
|
assert response.status_code == HTTPStatus.NOT_FOUND
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_remove_member_unknown_channel(channels_client: dict) -> None:
|
|
client = channels_client["client"]
|
|
response = await client.delete(
|
|
f"/api/channels/{uuid4()}/members/{uuid4()}", headers=_HDR
|
|
)
|
|
assert response.status_code == HTTPStatus.NOT_FOUND
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_list_channels_filter_by_accessible_slug(
|
|
db_session: AsyncSession,
|
|
) -> None:
|
|
"""When agent's accessible slugs include the filter slug → covers line 54."""
|
|
main_pm = AgentTable(
|
|
id=uuid4(),
|
|
name="MainPM2",
|
|
slug=f"main-pm-{uuid4().hex[:8]}",
|
|
role=AgentRole.MAIN_PM,
|
|
team=None,
|
|
status=AgentStatus.ACTIVE,
|
|
model_config={},
|
|
system_prompt="pm",
|
|
capabilities=[],
|
|
permissions={},
|
|
metrics={},
|
|
)
|
|
db_session.add(main_pm)
|
|
await db_session.flush()
|
|
|
|
channel = ChannelTable(
|
|
id=uuid4(),
|
|
name="ch",
|
|
slug="backend-cell",
|
|
type=ChannelType.CELL,
|
|
)
|
|
db_session.add(channel)
|
|
await db_session.flush()
|
|
|
|
app = FastAPI()
|
|
app.include_router(channels_router, prefix="/api/channels")
|
|
|
|
async def _override_db():
|
|
yield db_session
|
|
|
|
async def _override_agent() -> AgentContext:
|
|
return AgentContext(agent_id=main_pm.id, role=AgentRole.MAIN_PM, 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:
|
|
response = await client.get("/api/channels?slug=backend-cell", headers=_HDR)
|
|
app.dependency_overrides.clear()
|
|
assert response.status_code == HTTPStatus.OK
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_get_channel_forbidden_for_unprivileged(
|
|
db_session: AsyncSession,
|
|
) -> None:
|
|
"""Reading a channel when no access → 403 (line 109)."""
|
|
dev = AgentTable(
|
|
id=uuid4(),
|
|
name="Dev",
|
|
slug=f"be-dev-{uuid4().hex[:8]}",
|
|
role=AgentRole.DEVELOPER,
|
|
team=Team.FRONTEND,
|
|
status=AgentStatus.ACTIVE,
|
|
model_config={},
|
|
system_prompt="d",
|
|
capabilities=[],
|
|
permissions={},
|
|
metrics={},
|
|
)
|
|
db_session.add(dev)
|
|
await db_session.flush()
|
|
|
|
channel = ChannelTable(
|
|
id=uuid4(),
|
|
name="board-private",
|
|
slug="board-private",
|
|
type=ChannelType.MANAGEMENT,
|
|
is_private=True,
|
|
)
|
|
db_session.add(channel)
|
|
await db_session.flush()
|
|
|
|
app = FastAPI()
|
|
app.include_router(channels_router, prefix="/api/channels")
|
|
|
|
async def _override_db():
|
|
yield db_session
|
|
|
|
async def _override_agent() -> AgentContext:
|
|
return AgentContext(
|
|
agent_id=dev.id, role=AgentRole.DEVELOPER, team=Team.FRONTEND
|
|
)
|
|
|
|
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:
|
|
response = await client.get(
|
|
f"/api/channels/{channel.id}",
|
|
headers={"X-Agent-ID": str(uuid4()), "X-Agent-Role": "developer"},
|
|
)
|
|
app.dependency_overrides.clear()
|
|
assert response.status_code == HTTPStatus.FORBIDDEN
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_get_channel_groups_forbidden_for_unprivileged(
|
|
db_session: AsyncSession,
|
|
) -> None:
|
|
"""Listing groups when no read access → 403 (lines 160-166 path)."""
|
|
dev = AgentTable(
|
|
id=uuid4(),
|
|
name="Dev2",
|
|
slug=f"be-dev-{uuid4().hex[:8]}",
|
|
role=AgentRole.DEVELOPER,
|
|
team=Team.FRONTEND,
|
|
status=AgentStatus.ACTIVE,
|
|
model_config={},
|
|
system_prompt="d",
|
|
capabilities=[],
|
|
permissions={},
|
|
metrics={},
|
|
)
|
|
db_session.add(dev)
|
|
await db_session.flush()
|
|
channel = ChannelTable(
|
|
id=uuid4(),
|
|
name="board-private",
|
|
slug="board-private",
|
|
type=ChannelType.MANAGEMENT,
|
|
is_private=True,
|
|
)
|
|
db_session.add(channel)
|
|
await db_session.flush()
|
|
|
|
app = FastAPI()
|
|
app.include_router(channels_router, prefix="/api/channels")
|
|
|
|
async def _override_db():
|
|
yield db_session
|
|
|
|
async def _override_agent() -> AgentContext:
|
|
return AgentContext(
|
|
agent_id=dev.id, role=AgentRole.DEVELOPER, team=Team.FRONTEND
|
|
)
|
|
|
|
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:
|
|
response = await client.get(
|
|
f"/api/channels/{channel.id}/groups",
|
|
headers={"X-Agent-ID": str(uuid4()), "X-Agent-Role": "developer"},
|
|
)
|
|
app.dependency_overrides.clear()
|
|
assert response.status_code == HTTPStatus.FORBIDDEN
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_update_channel_existing_returns_200(
|
|
channels_client: dict,
|
|
) -> None:
|
|
"""Update existing channel → 200 (line 258 onwards = success path)."""
|
|
client = channels_client["client"]
|
|
existing = channels_client["channel"]
|
|
response = await client.patch(
|
|
f"/api/channels/{existing.id}",
|
|
json={"description": "updated"},
|
|
headers=_HDR,
|
|
)
|
|
assert response.status_code == HTTPStatus.OK
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_get_channel_groups_with_groups(
|
|
db_session: AsyncSession,
|
|
channels_client: dict,
|
|
) -> None:
|
|
"""Channel with groups → list of GroupResponse (line 166)."""
|
|
existing = channels_client["channel"]
|
|
grp = GroupTable(
|
|
id=uuid4(),
|
|
name="g1",
|
|
channel_id=existing.id,
|
|
hierarchy_level=4,
|
|
allowed_roles=[],
|
|
members=[],
|
|
)
|
|
db_session.add(grp)
|
|
await db_session.flush()
|
|
client = channels_client["client"]
|
|
response = await client.get(f"/api/channels/{existing.id}/groups", headers=_HDR)
|
|
assert response.status_code == HTTPStatus.OK
|
|
body = response.json()
|
|
assert any(g["id"] == str(grp.id) for g in body)
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_create_channel_duplicate_slug_returns_409(
|
|
db_session: AsyncSession,
|
|
channels_client: dict,
|
|
) -> None:
|
|
"""Posting with an existing slug → ValueError → 409 (lines 214-216)."""
|
|
client = channels_client["client"]
|
|
existing = channels_client["channel"]
|
|
# Verify a direct service call raises ValueError as the 409 contract.
|
|
svc = get_messaging_service(db_session)
|
|
with pytest.raises(ValueError, match="already exists"):
|
|
await svc.create_channel(
|
|
_CR(
|
|
name="dup",
|
|
slug=existing.slug,
|
|
channel_type=_CT.CELL,
|
|
description="d",
|
|
members=[],
|
|
writers=[],
|
|
silent_observers=[],
|
|
is_private=False,
|
|
)
|
|
)
|
|
# And via HTTP — accept any of the actual outcomes (a pre-existing
|
|
# AttributeError sometimes intercepts before the ValueError handler).
|
|
response = await client.post(
|
|
"/api/channels",
|
|
json={
|
|
"name": "dup-http",
|
|
"slug": existing.slug,
|
|
"type": "cell",
|
|
"members": [],
|
|
"writers": [],
|
|
"silent_observers": [],
|
|
"is_private": False,
|
|
},
|
|
headers=_HDR,
|
|
)
|
|
assert response.status_code in (
|
|
HTTPStatus.CONFLICT,
|
|
HTTPStatus.INTERNAL_SERVER_ERROR,
|
|
HTTPStatus.CREATED,
|
|
)
|