mirror of
https://github.com/rennf93/roboco.git
synced 2026-08-03 07:23:24 +02:00
bb3b4b0c6d
* feat(gateway): reviewer/PM collision map (W5)
The collision surface (intends_to_touch / adds_migration / touches_shared)
is authored at delegate time, consumed once by SequencingService to wire
dependency edges, then never shown to a reviewer again. This surfaces it:
- Pure builder (services/gateway/choreographer/collision.py): for a task
under review, the surfaced siblings (same parent) that would collide —
file-overlap globs or a shared migration chain (both adds_migration) —
with the overlapping globs and a declared-vs-actual drift check. No
DB/IO; callers fetch siblings (one indexed get_subtasks query, mig 069)
+ actual files (git). Caps: 10 siblings, 5 globs.
- Evidence envelopes: collision_context block injected into QA
claim_review, PR-gate claim_gate_review (both carry real touched files
so drift is populated), and the PM i_will_plan briefing (no actual
files at plan time, drift omitted). Best-effort — a failure omits the
block, never breaks the verb/briefing. Empty block omitted (zero token
cost via _EVIDENCE_OMIT_WHEN_EMPTY).
- Panel: GET /api/tasks/{id}/collision-map (declared surface + sibling
overlap; no drift — the panel route resolves no workspace) + a Collision
tab on the task detail (8th tab). Mock-mode returns an empty map.
- docs/map added to the RAG auto-index dirs so the collision-map concept
is fleet-retrievable; skipped gracefully if the dir is absent.
19 new tests (15 unit on the pure builder + 4 integration on the route).
Gate green: ruff/mypy/xenon (module rank A)/pytest 13000/coverage 94.81%,
panel typecheck/lint/516 tests.
* [w6-telegram] Add Telegram notifications bridge (V1)
CEO-facing Telegram DM bridge, flag-gated off by default
(ROBOCO_TELEGRAM_ENABLED). Mirrors the X-credentials / X-client pattern:
- TelegramCredentialsTable (migration 073) — singleton Fernet-encrypted
bot_token + chat_id, all-or-nothing set/clear; API never returns plaintext.
- TelegramClient ABC / NullTelegramClient (no-op, configured->False, never
raises) / LiveTelegramClient (httpx POST sendMessage) / build_telegram_client
factory (Null when creds unset).
- /telegram/credentials CEO-only routes (write-only, guard-decorated).
- Best-effort _notify_telegram fan-out from the two CEO-notify producers
(notify_ceo_of_escalation, notify_ceo_of_completion) — guarded by the flag,
never raises into the producer, carries a panel deep-link when
panel_base_url is set.
- panel credentials card (2 fields) nested in the Telegram feature-flag row.
- panel_base_url + telegram_timeout_seconds config fields.
V1 scope only: credentials + flag + panel card + client + one-line fan-out.
Out of scope (V2): inbound commands, a TelegramEngine background loop, a
dedup ledger, a bus subscription.
* [w6-telegram] fix: slave mypy/xenon regression (product tests + helper extract)
Pre-existing on slave from prior session's merges — no PR's CI caught them
(squash merges don't re-CI the result; each branch was based on older slave).
- test_product: _product helper returned MagicMock -> list invariant error;
cast to ProductTable, move import under TYPE_CHECKING.
- test_usage: svc.session.execute (AsyncSession) has no call_args_list;
cast to MagicMock at the two call sites.
- product.progress_for_products: xenon rank C -> extract module-level
_project_to_products_map helper (repo pattern: helper-extract).
---------
Co-authored-by: Renn F <rennf93@users.noreply.github.com>
94 lines
3.0 KiB
Python
94 lines
3.0 KiB
Python
"""TelegramCredentialsService coverage — encrypt/roundtrip, all-or-nothing set/clear.
|
|
|
|
Drives a real ``db_session`` via the project's Postgres-backed conftest. The
|
|
service never returns plaintext to a caller other than ``get_decrypted`` (the
|
|
server-side-only reader) — the API layer only ever sees ``has_credentials``.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
from typing import TYPE_CHECKING
|
|
|
|
import pytest
|
|
import pytest_asyncio
|
|
from roboco.db.tables import TelegramCredentialsTable
|
|
from roboco.services.telegram_credentials import (
|
|
TelegramCredentialsService,
|
|
TelegramCredentialsValidationError,
|
|
get_telegram_credentials_service,
|
|
)
|
|
from sqlalchemy import select
|
|
|
|
if TYPE_CHECKING:
|
|
from collections.abc import AsyncIterator
|
|
|
|
from sqlalchemy.ext.asyncio import AsyncSession
|
|
|
|
_CREDS = {"bot_token": "123456:ABC-bot-token", "chat_id": "987654321"}
|
|
|
|
|
|
@pytest_asyncio.fixture
|
|
async def svc(
|
|
db_session: AsyncSession,
|
|
) -> AsyncIterator[TelegramCredentialsService]:
|
|
yield get_telegram_credentials_service(db_session)
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_unset_has_no_credentials(svc: TelegramCredentialsService) -> None:
|
|
assert await svc.has_credentials() is False
|
|
assert await svc.get_decrypted() is None
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_set_both_encrypts_and_roundtrips(
|
|
svc: TelegramCredentialsService,
|
|
) -> None:
|
|
has_creds = await svc.set_credentials(**_CREDS)
|
|
assert has_creds is True
|
|
assert await svc.has_credentials() is True
|
|
|
|
decrypted = await svc.get_decrypted()
|
|
assert decrypted is not None
|
|
assert decrypted.bot_token == _CREDS["bot_token"]
|
|
assert decrypted.chat_id == _CREDS["chat_id"]
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_stored_row_never_holds_plaintext(
|
|
svc: TelegramCredentialsService, db_session: AsyncSession
|
|
) -> None:
|
|
await svc.set_credentials(**_CREDS)
|
|
result = await db_session.execute(select(TelegramCredentialsTable).limit(1))
|
|
row = result.scalar_one_or_none()
|
|
assert row is not None
|
|
assert row.bot_token_encrypted != _CREDS["bot_token"]
|
|
assert row.chat_id_encrypted != _CREDS["chat_id"]
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_clearing_both_removes_row(svc: TelegramCredentialsService) -> None:
|
|
await svc.set_credentials(**_CREDS)
|
|
has_creds = await svc.set_credentials(bot_token="", chat_id="")
|
|
assert has_creds is False
|
|
assert await svc.has_credentials() is False
|
|
assert await svc.get_decrypted() is None
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_partial_set_is_rejected(svc: TelegramCredentialsService) -> None:
|
|
with pytest.raises(TelegramCredentialsValidationError):
|
|
await svc.set_credentials(bot_token="only-one", chat_id="")
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_rotate_overwrites_previous_values(
|
|
svc: TelegramCredentialsService,
|
|
) -> None:
|
|
await svc.set_credentials(**_CREDS)
|
|
rotated = {k: f"{v}-rotated" for k, v in _CREDS.items()}
|
|
await svc.set_credentials(**rotated)
|
|
decrypted = await svc.get_decrypted()
|
|
assert decrypted is not None
|
|
assert decrypted.bot_token == rotated["bot_token"]
|