Skip to content
Python
8.9 KB
Raw Blame
"""Telegram approval owners (OPE-217 / #712), the follow-up to #567.

#567 made `_actor_owns_protected_item` refuse every Telegram reply because Telegram had no
approval-owner model. These tests pin the model that replaces that blanket refusal:

- the reply must arrive in the chat the item's inbox is bound to;
- with owners configured, the sender must be one of them;
- with no owners and a private-chat binding, the one allowed human in that chat is the
  owner (a Telegram DM's chat id is the user's id), so single-user bots need no setup;
- with no owners and a group binding, nobody may approve until owners are chosen;
- a refused tagged reply gets a one-line answer instead of silence.
"""

from __future__ import annotations

import asyncio

from coworker.connectors.base import InteractionEvent, MessageEvent, SessionSource
from coworker.connectors.gateway import APPROVAL_OWNER_REQUIRED
from coworker.interactions import encode
from coworker.providers import ModelCapabilities, ProviderClient
from coworker.server.manager import SessionManager

OWNER = "8894780782"  # bound DM: chat id == user id
OTHER = "8883353200"  # allowed to message, never an owner
GROUP = "-1001234567890"


class NoTurnsProvider(ProviderClient):
    def complete(self, *, model, messages, tools=None, **settings):
        raise AssertionError("no model turns expected")

    def capabilities(self, model):
        return ModelCapabilities()


class GatewayStub:
    """Records outbound text so the refusal reply can be asserted."""

    def __init__(self):
        self.sent: list[tuple[str, str]] = []
        self.rejections: list = []
        self.settings: dict = {}

    async def deliver(self, target, text):
        self.sent.append((target, text))

    async def reject_interaction(self, event, text=""):
        self.rejections.append(getattr(event, "user_id", None))

    async def update_message(self, *args):
        raise AssertionError("a refused interaction must not update the message")


def _manager(tmp_path, *, owners=None, allowed=(OWNER, OTHER), bind_to=OWNER) -> SessionManager:
    manager = SessionManager(data_dir=tmp_path / "data", provider=NoTurnsProvider())
    profile = {"bot_token": "123:abc", "enabled": True, "allowed_users": list(allowed)}
    if owners is not None:
        profile["approval_owner_ids"] = list(owners)
    manager.secrets.put("telegram:default", profile)
    if bind_to is not None:
        manager.inbox_routing.set_binding("default", channel="telegram", target=bind_to)
    return manager


def _reply(text: str, *, user_id: str, chat_id: str) -> MessageEvent:
    return MessageEvent(
        text=text,
        source=SessionSource(
            platform="telegram",
            chat_id=chat_id,
            user_id=user_id,
            user_name="someone",
            chat_type="group" if chat_id.startswith("-") else "dm",
        ),
    )


def _approve(manager, item, *, user_id, chat_id) -> bool:
    return manager._resolve_inbox_reply(
        _reply(f"approve [ow:{item.id}]", user_id=user_id, chat_id=chat_id)
    )


# -- no owners configured, bound to the owner's private chat ------------------------------

def test_bound_dm_user_approves_without_configuring_owners(tmp_path):
    manager = _manager(tmp_path)
    item = manager.inbox.add_approval("s1", "Run it?")
    assert _approve(manager, item, user_id=OWNER, chat_id=OWNER) is True
    assert manager.inbox.get(item.id).state == "resolved"
    assert manager.inbox.get(item.id).resolution == "allow"


def test_allowed_non_owner_replying_from_their_own_dm_is_refused(tmp_path):
    # The #519 scenario: allowed to message, replies from a different chat than the bound one.
    manager = _manager(tmp_path)
    item = manager.inbox.add_approval("s1", "Run it?")
    consumed = _approve(manager, item, user_id=OTHER, chat_id=OTHER)
    assert consumed is True  # the tag was recognised, so the message is not routed as a turn
    assert manager.inbox.get(item.id).state == "pending"


def test_owner_replying_from_another_chat_is_refused(tmp_path):
    manager = _manager(tmp_path)
    item = manager.inbox.add_approval("s1", "Run it?")
    assert _approve(manager, item, user_id=OWNER, chat_id=GROUP) is True
    assert manager.inbox.get(item.id).state == "pending"


# -- owners configured -------------------------------------------------------------------

def test_configured_owner_approves_and_allowed_non_owner_is_refused(tmp_path):
    manager = _manager(tmp_path, owners=[OWNER])
    item = manager.inbox.add_approval("s1", "Run it?")
    assert _approve(manager, item, user_id=OTHER, chat_id=OWNER) is True
    assert manager.inbox.get(item.id).state == "pending"
    assert _approve(manager, item, user_id=OWNER, chat_id=OWNER) is True
    assert manager.inbox.get(item.id).state == "resolved"


def test_group_binding_with_owners_lets_only_owners_approve(tmp_path):
    manager = _manager(tmp_path, owners=[OWNER], bind_to=GROUP)
    item = manager.inbox.add_approval("s1", "Run it?")
    assert _approve(manager, item, user_id=OTHER, chat_id=GROUP) is True
    assert manager.inbox.get(item.id).state == "pending"
    assert _approve(manager, item, user_id=OWNER, chat_id=GROUP) is True
    assert manager.inbox.get(item.id).state == "resolved"


def test_group_binding_without_owners_refuses_everyone(tmp_path):
    manager = _manager(tmp_path, bind_to=GROUP)
    item = manager.inbox.add_approval("s1", "Run it?")
    for user in (OWNER, OTHER):
        assert _approve(manager, item, user_id=user, chat_id=GROUP) is True
        assert manager.inbox.get(item.id).state == "pending"


def test_in_app_only_inbox_is_not_resolvable_from_telegram(tmp_path):
    manager = _manager(tmp_path, bind_to=None)
    item = manager.inbox.add_approval("s1", "Run it?")
    assert _approve(manager, item, user_id=OWNER, chat_id=OWNER) is True
    assert manager.inbox.get(item.id).state == "pending"


def test_questions_stay_answerable_by_any_allowed_member(tmp_path):
    manager = _manager(tmp_path)
    question = manager.inbox.add_question("s1", "Which region?", options=["A", "B"])
    assert manager._resolve_inbox_reply(
        _reply(f"A [ow:{question.id}]", user_id=OTHER, chat_id=OTHER)
    ) is True
    assert manager.inbox.get(question.id).resolution == "A"


# -- owner list editing -------------------------------------------------------------------

def test_adding_an_owner_implies_allowed_and_removal_keeps_allowed(tmp_path):
    manager = _manager(tmp_path, allowed=())
    assert manager.set_telegram_approval_owner("42", add=True, display_name="Rohit")["ok"]
    profile = manager.secrets.get("telegram:default")
    assert profile["approval_owner_ids"] == ["42"]
    assert profile["allowed_users"] == ["42"]
    assert manager.set_telegram_approval_owner("42", add=False)["ok"]
    profile = manager.secrets.get("telegram:default")
    assert profile["approval_owner_ids"] == []
    assert profile["allowed_users"] == ["42"]


def test_owner_edit_requires_a_connected_telegram(tmp_path):
    manager = SessionManager(data_dir=tmp_path / "data", provider=NoTurnsProvider())
    result = manager.set_telegram_approval_owner("42", add=True)
    assert not result["ok"]


# -- refusal feedback ---------------------------------------------------------------------

def test_refused_text_reply_gets_a_one_line_answer(tmp_path):
    manager = _manager(tmp_path)
    gateway = GatewayStub()
    manager.gateway = gateway
    item = manager.inbox.add_approval("s1", "Run it?")

    async def run():
        # The resolver is called synchronously from inside the gateway's loop in production.
        assert _approve(manager, item, user_id=OTHER, chat_id=OTHER) is True
        await asyncio.sleep(0)  # let the scheduled send run

    asyncio.run(run())
    assert manager.inbox.get(item.id).state == "pending"
    assert gateway.sent == [(f"telegram:{OTHER}", APPROVAL_OWNER_REQUIRED)]


def test_accepted_reply_sends_no_refusal(tmp_path):
    manager = _manager(tmp_path)
    gateway = GatewayStub()
    manager.gateway = gateway
    item = manager.inbox.add_approval("s1", "Run it?")

    async def run():
        assert _approve(manager, item, user_id=OWNER, chat_id=OWNER) is True
        await asyncio.sleep(0)

    asyncio.run(run())
    assert manager.inbox.get(item.id).state == "resolved"
    assert gateway.sent == []


def test_refused_button_click_on_telegram_gets_a_plain_reply(tmp_path):
    manager = _manager(tmp_path)
    gateway = GatewayStub()
    manager.gateway = gateway
    item = manager.inbox.add_approval("s1", "Run it?")
    asyncio.run(
        manager._on_interaction(
            InteractionEvent(
                platform="telegram",
                chat_id=OTHER,
                message_id="1",
                value=encode(item.id, "allow"),
                user_id=OTHER,
                user_name="someone",
            )
        )
    )
    assert manager.inbox.get(item.id).state == "pending"
    assert gateway.sent == [(f"telegram:{OTHER}", APPROVAL_OWNER_REQUIRED)]
    assert gateway.rejections == [OTHER]  # the generic reject path still runs (no-op off Slack)