refactor: replace object.__setattr__ hacks with aiogram's MockedBot pattern

Adapted aiogram's own MockedBot/MockedSession from their test suite.
Real Message/CallbackQuery objects get a MockedBot injected via .as_(bot),
and outgoing API calls are captured via bot.get_request() for assertion.

The "connected" path (asyncio.gather with callback.answer + send_to_user)
still needs object.__setattr__ for callback.answer because aiogram's
TelegramMethod objects are unhashable, which breaks asyncio.gather's
dedup logic. This is isolated to 2 tests; the callback.answer path is
verified in the first-accept tests via MockedBot.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: vzakharov

docs/250219_tests.md

@@ -4,7 +4,7 @@
 
 - **Coverage target**: ~60-70% initially (critical paths: matcher, profiler, handlers)
 - **pgvector**: Mock `_find_similar_users()` and `get_embedding()` — no Docker needed
-- **Telegram handlers**: Direct handler invocation with `object.__setattr__` to mock methods on frozen aiogram Pydantic models
+- **Telegram handlers**: Direct handler invocation with aiogram's own `MockedBot` pattern (adapted from their test suite) — real Message/CallbackQuery objects with bot injected via `.as_(bot)`, outgoing API calls captured via `bot.get_request()`
 - **Database**: In-memory SQLite with savepoint-based test isolation
 - **Always**: `uv run pyright` before `uv run pytest`, commit after each bite-sized piece
 

tests/handlers/helpers.py

@@ -1,94 +1,110 @@
-"""Reusable factories for fake aiogram types used in handler tests."""
+"""Reusable factories for fake aiogram types used in handler tests.
+
+Uses aiogram's own MockedBot pattern: real Message/CallbackQuery objects
+with a MockedBot injected via .as_(bot).  Outgoing API calls are captured
+and can be inspected via bot.get_request().
+"""
 
 from collections.abc import AsyncGenerator
 from contextlib import asynccontextmanager
 from datetime import datetime
-from typing import NamedTuple
-from unittest.mock import AsyncMock
+from unittest.mock import patch
 
+from aiogram.methods import AnswerCallbackQuery, SendMessage
 from aiogram.types import CallbackQuery, Message
 from aiogram.types import Chat as TgChat
 from aiogram.types import User as TgUser
 from sqlalchemy.ext.asyncio import AsyncSession
 
+from .mocked_bot import MockedBot
+
+# Reusable dummy Message result for staging SendMessage responses.
+_DUMMY_MSG = Message(
+    message_id=999,
+    date=datetime.now(),
+    chat=TgChat(id=1, type="private"),
+)
+
+
+def make_bot() -> MockedBot:
+    return MockedBot()
+
 
-class FakeMessage(NamedTuple):
-    message: Message
-    answer: AsyncMock
+def _stage_send_message(bot: MockedBot) -> None:
+    """Pre-stage a successful SendMessage response."""
+    bot.add_result_for(SendMessage, ok=True, result=_DUMMY_MSG)
 
 
-class FakeCallback(NamedTuple):
-    callback: CallbackQuery
-    answer: AsyncMock
-    msg_edit_text: AsyncMock
-    msg_answer: AsyncMock
+def _stage_callback_answer(bot: MockedBot) -> None:
+    """Pre-stage a successful AnswerCallbackQuery response."""
+    bot.add_result_for(AnswerCallbackQuery, ok=True, result=True)
 
 
 def make_message(
+    bot: MockedBot,
     text: str = "hello",
     user_id: int = 12345,
     message_id: int = 1,
-) -> FakeMessage:
-    """Create a fake Message with mocked answer/reply methods."""
-    answer_mock = AsyncMock(name="message.answer")
+    *,
+    stage_replies: int = 1,
+) -> Message:
+    """Create a real Message with MockedBot injected.
+
+    Args:
+        stage_replies: how many SendMessage responses to pre-stage
+                       (one per expected message.answer() call).
+    """
     msg = Message(
         message_id=message_id,
         date=datetime.now(),
         chat=TgChat(id=user_id, type="private"),
         from_user=TgUser(id=user_id, is_bot=False, first_name="Test"),
         text=text,
     )
-    object.__setattr__(msg, "answer", answer_mock)
-    return FakeMessage(message=msg, answer=answer_mock)
+    msg.as_(bot)
+    for _ in range(stage_replies):
+        _stage_send_message(bot)
+    return msg
 
 
 def make_callback(
+    bot: MockedBot,
     data: str,
     user_id: int = 12345,
     message_id: int = 1,
-) -> FakeCallback:
-    """Create a fake CallbackQuery with mocked answer method and attached message."""
-    edit_text_mock = AsyncMock(name="message.edit_text")
-    msg_answer_mock = AsyncMock(name="message.answer")
-    cb_answer_mock = AsyncMock(name="callback.answer")
-
+    *,
+    stage_replies: int = 1,
+) -> CallbackQuery:
+    """Create a real CallbackQuery with MockedBot injected.
+
+    Args:
+        stage_replies: how many AnswerCallbackQuery responses to pre-stage.
+    """
     inner_msg = Message(
         message_id=message_id,
         date=datetime.now(),
         chat=TgChat(id=user_id, type="private"),
         from_user=TgUser(id=user_id, is_bot=False, first_name="Test"),
         text="original",
     )
-    object.__setattr__(inner_msg, "edit_text", edit_text_mock)
-    object.__setattr__(inner_msg, "answer", msg_answer_mock)
-    object.__setattr__(
-        inner_msg,
-        "edit_reply_markup",
-        AsyncMock(name="message.edit_reply_markup"),
-    )
-
     cb = CallbackQuery(
         id="test_cb_1",
         chat_instance="test",
         from_user=TgUser(id=user_id, is_bot=False, first_name="Test"),
         message=inner_msg,
         data=data,
     )
-    object.__setattr__(cb, "answer", cb_answer_mock)
-    return FakeCallback(
-        callback=cb,
-        answer=cb_answer_mock,
-        msg_edit_text=edit_text_mock,
-        msg_answer=msg_answer_mock,
-    )
+    cb.as_(bot)
+    for _ in range(stage_replies):
+        _stage_callback_answer(bot)
+    return cb
 
 
 @asynccontextmanager
 async def patch_get_db(
     session: AsyncSession,
 ) -> AsyncGenerator[None, None]:
     """Context manager that patches get_db in both handlers and activation module."""
-    from unittest.mock import patch
 
     async def fake_get_db() -> AsyncGenerator[AsyncSession, None]:
         yield session

tests/handlers/mocked_bot.py

@@ -0,0 +1,101 @@
+"""MockedBot for testing — adapted from aiogram's own test suite.
+
+Instead of hitting Telegram's API, MockedSession captures outgoing requests
+in a deque and returns pre-staged responses.  Usage:
+
+    bot = MockedBot()
+    msg.as_(bot)                              # inject into TelegramObject
+    bot.add_result_for(SendMessage, ok=True)  # stage a response
+    await handler(msg)                        # run the handler
+    req = bot.get_request()                   # inspect what was sent
+    assert isinstance(req, SendMessage)
+    assert req.text == "expected"
+
+Source: https://github.com/aiogram/aiogram/blob/dev-3.x/tests/mocked_bot.py
+"""
+
+from collections import deque
+from collections.abc import AsyncGenerator
+
+from aiogram import Bot
+from aiogram.client.session.base import BaseSession
+from aiogram.methods import TelegramMethod
+from aiogram.methods.base import Response, TelegramType
+from aiogram.types import ResponseParameters, User
+
+
+class MockedSession(BaseSession):
+    def __init__(self) -> None:
+        super().__init__()
+        self.responses: deque[Response[object]] = deque()
+        self.requests: deque[TelegramMethod[object]] = deque()
+        self.closed = True
+
+    def add_result(self, response: Response[object]) -> None:
+        self.responses.append(response)
+
+    def get_request(self) -> TelegramMethod[object]:
+        return self.requests.pop()
+
+    async def close(self) -> None:
+        self.closed = True
+
+    async def make_request(
+        self,
+        bot: Bot,
+        method: TelegramMethod[TelegramType],
+        timeout: int | None = None,
+    ) -> TelegramType:
+        self.closed = False
+        self.requests.append(method)  # type: ignore[arg-type]
+        response = self.responses.pop()
+        self.check_response(
+            bot=bot,
+            method=method,
+            status_code=response.error_code or 200,
+            content=response.model_dump_json(),
+        )
+        return response.result  # type: ignore[return-value]
+
+    async def stream_content(
+        self,
+        url: str,
+        headers: dict[str, str] | None = None,
+        timeout: int = 30,
+        chunk_size: int = 65536,
+        raise_for_status: bool = True,
+    ) -> AsyncGenerator[bytes, None]:  # pragma: no cover
+        yield b""
+
+
+class MockedBot(Bot):
+    session: MockedSession  # type: ignore[assignment]
+
+    def __init__(self) -> None:
+        super().__init__("42:TEST", session=MockedSession())
+        self._me = User(
+            id=self.id,
+            is_bot=True,
+            first_name="TestBot",
+            username="test_bot",
+        )
+
+    def add_result_for(
+        self,
+        method: type[TelegramMethod[TelegramType]],
+        ok: bool,
+        result: TelegramType | None = None,
+        description: str | None = None,
+        error_code: int = 200,
+    ) -> None:
+        response = Response[method.__returning__](  # type: ignore[name-defined]
+            ok=ok,
+            result=result,
+            description=description,
+            error_code=error_code,
+            parameters=ResponseParameters(),
+        )
+        self.session.add_result(response)
+
+    def get_request(self) -> TelegramMethod[object]:
+        return self.session.get_request()