Merge agent/trim: drop dead code and merge duplicate tests

lumen_commands.py

@@ -1006,11 +1006,6 @@ async def handle_pick_callback(query: CallbackQuery) -> None:
         with contextlib.suppress(Exception):
             await query.answer()
         return
-    if not _is_rec_owner(rec):
-        # Та же проверка авторства, что выше до перевыпуска (дубль убран, поведение то же).
-        with contextlib.suppress(Exception):
-            await query.answer(_lang_t(rec_lang, "pick_not_yours"), show_alert=True)
-        return
     # Все проверки пройдены — только теперь забираем токен (см. комментарий у get выше).
     # Без сообщения кнопки не во что упереть: токен не трогаем, иначе тап из инлайн
     # режима сжёг бы чужой выбор без дела.

lumen_message_parse.py

@@ -181,28 +181,6 @@ _PICK_EXACT_TOPICS: dict[str, str] = {
     "игре": "games", "игр": "games", "играть": "games", "поиграть": "games",
 }
 _PICK_MAX_LEN = 60
-PICK_QUESTIONS: dict[str, str] = {
-    "film": "Что сегодня хочется?",
-    "series": "Что сегодня хочется?",
-    "music": "Какое настроение?",
-    "books": "Что сегодня хочется?",
-    "games": "Во что хочется?",
-}
-PICK_OPTIONS: dict[str, list[str]] = {
-    "film": ["Лёгкое и весёлое", "Драма", "Триллер", "Фантастика"],
-    "series": ["Лёгкое и весёлое", "Драма", "Детектив", "Фантастика"],
-    "music": ["Энергичное", "Спокойное", "Грустное", "Весёлое"],
-    "books": ["Фантастика", "Детектив", "Нон-фикшн", "Классика"],
-    "games": ["Экшен", "Стратегия", "RPG", "Головоломка"],
-}
-# Как выбор дописывается к исходному запросу перед обычным маршрутом.
-PICK_CHOICE_TEMPLATES: dict[str, str] = {
-    "film": "{original} (жанр: {choice})",
-    "series": "{original} (жанр: {choice})",
-    "music": "{original} (настроение: {choice})",
-    "books": "{original} (жанр: {choice})",
-    "games": "{original} (жанр: {choice})",
-}
 
 def match_pick_request(text_lower: str) -> str | None:
     """Возвращает id pick-сценария (film/music/...), если текст — вкусовой

lumen_router_config.py

@@ -354,7 +354,7 @@ def _gemini_route(models: list[str]) -> list[tuple[str, str]]:
 
 # ── Groq (прямой провайдер, не через OpenRouter) ──
 # Калибровка живьём 21.09.2026: Qwen голова (чисто и по делу), gpt-oss второй (представляется ChatGPT и тратит reasoning-токены). Лимиты free: 30 RPM / 1000 RPD / 8K TPM / 200K TPD.
-GROQ_BASE_URL = "https://api.groq.com/openai/v1"
+# Базовый URL один: bot.GROQ_BASE_URL, дубля здесь нет (аудит 05.10.2026).
 _GROQ_LIGHT_ORDER: list[str] = [
     "qwen/qwen3.8-27b",
     "openai/gpt-oss-120b",

lumen_routes.py

@@ -738,8 +738,6 @@ async def ask_gemini(
     import bot
     state = bot.get_state(chat_id)
     chain = list(model_chain) if model_chain else list(GEMINI_DEFAULT_CHAIN)
-    if not chain:
-        chain = list(GEMINI_DEFAULT_CHAIN)
     if deadline is None:
         deadline = time.monotonic() + bot.ROUTE_TOTAL_BUDGET_SEC
     hist = state.setdefault("history", [])

lumen_security.py

@@ -221,14 +221,6 @@ _INJECTION_PROBE_RE = re.compile(
     re.IGNORECASE,
 )
 
-def _normalize_for_detection(text: str) -> str:
-    # Обход через невидимки/совместимые символы: чистим копию для проверки.
-    if not text:
-        return text
-    norm = unicodedata.normalize("NFKC", text)
-    return "".join(ch for ch in norm if unicodedata.category(ch) != "Cf")
-
-
 def _looks_like_injection_probe(text: str) -> bool:
     """Чистая функция — тестируется отдельно от _handle_message_core."""
     if not text:

tests/test_bot_commands.py

@@ -310,50 +310,51 @@ def test_build_version_caches_git_call(monkeypatch):
         monkeypatch.setattr(lc, "_BUILD_VERSION_CACHED", None)
 
 
-def test_match_trigger_prefix_finds_draw_trigger():    assert bot._match_trigger_prefix("нарисуй кота на пляже", bot.DRAW_TRIGGER_PREFIXES) == "нарисуй"
-
-
-def test_match_trigger_prefix_finds_tts_trigger():
-    assert bot._match_trigger_prefix("озвучь этот текст пожалуйста", bot.TTS_TRIGGER_PREFIXES) == "озвучь"
-
-
-def test_match_trigger_prefix_new_synonyms_work():
-    assert bot._match_trigger_prefix("преврати в аудио вот это сообщение", bot.TTS_TRIGGER_PREFIXES) == "преврати в аудио"
-    assert bot._match_trigger_prefix("сгенери картинку заката", bot.DRAW_TRIGGER_PREFIXES) == "сгенери картинку"
-
-
-def test_match_trigger_prefix_no_false_positive_when_trigger_not_at_start():
-    # Триггерное слово упоминается, но НЕ в начале сообщения — не должно срабатывать
-    assert bot._match_trigger_prefix("объясни, как я мог бы нарисовать домик карандашом", bot.DRAW_TRIGGER_PREFIXES) is None
-    assert bot._match_trigger_prefix("что значит слово озвучь на украинском", bot.TTS_TRIGGER_PREFIXES) is None
-
-
-def test_match_trigger_prefix_no_false_positive_for_unrelated_text():
-    assert bot._match_trigger_prefix("привет, как дела?", bot.DRAW_TRIGGER_PREFIXES) is None
-    assert bot._match_trigger_prefix("привет, как дела?", bot.TTS_TRIGGER_PREFIXES) is None
-
-
-def test_match_trigger_prefix_ambiguous_phrases_deliberately_excluded():
-    # "хочу картинку"/"сделай картинку" намеренно НЕ триггеры — легко спутать с
-    # "хочу картинку тебе показать" или правкой уже присланного фото.
-    assert bot._match_trigger_prefix("хочу картинку показать тебе", bot.DRAW_TRIGGER_PREFIXES) is None
-    assert bot._match_trigger_prefix("сделай картинку ярче", bot.DRAW_TRIGGER_PREFIXES) is None
-
-
-def test_match_trigger_prefix_new_voice_and_draw_synonyms():
-    # Расширение синонимов (сентябрь 2026) — разговорные варианты тех же просьб.
-    assert bot._match_trigger_prefix("зачитай этот абзац", bot.TTS_TRIGGER_PREFIXES) == "зачитай"
-    assert bot._match_trigger_prefix("зачитай текст договора", bot.TTS_TRIGGER_PREFIXES) == "зачитай текст"
-    assert bot._match_trigger_prefix("прочти вслух мою историю", bot.TTS_TRIGGER_PREFIXES) == "прочти вслух"
-    assert bot._match_trigger_prefix("сгенерируй мне изображение замка", bot.DRAW_TRIGGER_PREFIXES) == "сгенерируй мне изображение"
-    assert bot._match_trigger_prefix("создай мне картинку с котом", bot.DRAW_TRIGGER_PREFIXES) == "создай мне картинку"
-
-
-def test_match_trigger_prefix_long_phrase_wins_over_short_prefix():
-    # Порядок в списке: "прочти вслух" стоит раньше "прочти" — иначе короткий
-    # префикс съест начало ("прочти" вместо "прочти вслух").
-    assert bot._match_trigger_prefix("озвучь этот текст пожалуйста", bot.TTS_TRIGGER_PREFIXES) == "озвучь"
-    assert bot._match_trigger_prefix("прочти вслух", bot.TTS_TRIGGER_PREFIXES) == "прочти вслух"
+@pytest.mark.parametrize(("text", "prefixes", "expected"), [
+    ("нарисуй кота на пляже", bot.DRAW_TRIGGER_PREFIXES, "нарисуй"),
+    ("озвучь этот текст пожалуйста", bot.TTS_TRIGGER_PREFIXES, "озвучь"),
+    ("преврати в аудио вот это сообщение", bot.TTS_TRIGGER_PREFIXES, "преврати в аудио"),
+    ("сгенери картинку заката", bot.DRAW_TRIGGER_PREFIXES, "сгенери картинку"),
+    # Разговорные синонимы (сентябрь 2026).
+    ("зачитай этот абзац", bot.TTS_TRIGGER_PREFIXES, "зачитай"),
+    ("зачитай текст договора", bot.TTS_TRIGGER_PREFIXES, "зачитай текст"),
+    ("прочти вслух мою историю", bot.TTS_TRIGGER_PREFIXES, "прочти вслух"),
+    ("сгенерируй мне изображение замка", bot.DRAW_TRIGGER_PREFIXES, "сгенерируй мне изображение"),
+    ("создай мне картинку с котом", bot.DRAW_TRIGGER_PREFIXES, "создай мне картинку"),
+    # Длинная фраза побеждает короткий префикс (порядок спи��ка).
+    ("прочти вслух", bot.TTS_TRIGGER_PREFIXES, "прочти вслух"),
+    # Граница слова и вежливые формы.
+    ("прочтите этот текст", bot.TTS_TRIGGER_PREFIXES, "прочтите"),
+    ("прочтите вслух сказку", bot.TTS_TRIGGER_PREFIXES, "прочтите вслух"),
+    ("озвучьте текст", bot.TTS_TRIGGER_PREFIXES, "озвучьте"),
+    ("нарисуйте кота", bot.DRAW_TRIGGER_PREFIXES, "нарисуйте"),
+    # Английские триггеры из /start.
+    ("draw a cat on the beach", bot.DRAW_TRIGGER_PREFIXES, "draw a"),
+    ("generate an image of a castle", bot.DRAW_TRIGGER_PREFIXES, "generate an image"),
+    ("read this out loud please", bot.TTS_TRIGGER_PREFIXES, "read this out loud"),
+    ("voice this message", bot.TTS_TRIGGER_PREFIXES, "voice this"),
+])
+def test_match_trigger_prefix_finds_triggers(text, prefixes, expected):
+    assert bot._match_trigger_prefix(text, prefixes) == expected
+
+
+@pytest.mark.parametrize(("text", "prefixes"), [
+    ("объясни, как я мог бы нарисовать домик карандашом", bot.DRAW_TRIGGER_PREFIXES),
+    ("что значит слово озвучь на украинском", bot.TTS_TRIGGER_PREFIXES),
+    ("привет, как дела?", bot.DRAW_TRIGGER_PREFIXES),
+    ("привет, как дела?", bot.TTS_TRIGGER_PREFIXES),
+    # "хочу/сделай картинку" намеренно не триггеры: путаются с правкой присланного фото.
+    ("хочу картинку показать тебе", bot.DRAW_TRIGGER_PREFIXES),
+    ("сделай картинку ярче", bot.DRAW_TRIGGER_PREFIXES),
+    # Граница слова: голый startswith давал мусор ("нарисуйка" — с "нарисуй").
+    ("нарисуйка", bot.DRAW_TRIGGER_PREFIXES),
+    ("how are you", bot.DRAW_TRIGGER_PREFIXES),
+    ("how are you", bot.TTS_TRIGGER_PREFIXES),
+    # Идиома "draw conclusions", а не просьба нарисовать.
+    ("draw some conclusions here", bot.DRAW_TRIGGER_PREFIXES),
+])
+def test_match_trigger_prefix_rejects_non_triggers(text, prefixes):
+    assert bot._match_trigger_prefix(text, prefixes) is None
 
 
 def test_strip_reply_marker_treats_demonstratives_as_empty():
@@ -370,32 +371,6 @@ def test_strip_reply_marker_treats_demonstratives_as_empty():
     assert bot._strip_reply_marker("этот текст, пожалуйста") == "этот текст, пожалуйста"
 
 
-def test_match_trigger_prefix_requires_word_boundary_and_polite_forms():
-    # Найдено код-ревью: чистый startswith без границы слова давал мусор —
-    # "прочтите" начиналось с "прочти" (остаток "те..."), "нарисуйка" — с
-    # "нарисуй". Теперь после префикса нужны конец строки/пробел/пунктуация.
-    assert bot._match_trigger_prefix("нарисуйка", bot.DRAW_TRIGGER_PREFIXES) is None
-    assert bot._match_trigger_prefix("прочтите этот текст", bot.TTS_TRIGGER_PREFIXES) == "прочтите"
-    assert bot._match_trigger_prefix("прочтите вслух сказку", bot.TTS_TRIGGER_PREFIXES) == "прочтите вслух"
-    assert bot._match_trigger_prefix("озвучьте текст", bot.TTS_TRIGGER_PREFIXES) == "озвучьте"
-    assert bot._match_trigger_prefix("нарисуйте кота", bot.DRAW_TRIGGER_PREFIXES) == "нарисуйте"
-
-
-def test_match_trigger_prefix_english_triggers():
-    # Внешний аудит: /start обещает "draw a cat"/"read this out loud", а триггеры были только русские.
-    assert bot._match_trigger_prefix("draw a cat on the beach", bot.DRAW_TRIGGER_PREFIXES) == "draw a"
-    assert bot._match_trigger_prefix("generate an image of a castle", bot.DRAW_TRIGGER_PREFIXES) == "generate an image"
-    assert bot._match_trigger_prefix("read this out loud please", bot.TTS_TRIGGER_PREFIXES) == "read this out loud"
-    assert bot._match_trigger_prefix("voice this message", bot.TTS_TRIGGER_PREFIXES) == "voice this"
-    assert bot._match_trigger_prefix("how are you", bot.DRAW_TRIGGER_PREFIXES) is None
-    assert bot._match_trigger_prefix("how are you", bot.TTS_TRIGGER_PREFIXES) is None
-
-
-def test_match_trigger_prefix_rejects_draw_idiom():
-    # Ревью ветки: "draw some" ловил идиому "draw conclusions".
-    assert bot._match_trigger_prefix("draw some conclusions here", bot.DRAW_TRIGGER_PREFIXES) is None
-
-
 def test_tts_trigger_this_with_reply_voices_replied_message(rate_guard_setup):
     # Регрессия (сентябрь 2026): "озвучь это" в ответ на сообщение озвучивало
     # само слово "это" — остаток после триггера считался содержанием.
@@ -478,34 +453,21 @@ def test_draw_trigger_this_with_reply_draws_replied_message(rate_guard_setup):
     bot.inline_draw.assert_awaited_once_with(message, "закат над морем")
 
 
-def test_pick_image_model_detects_anime():
-    assert bot._pick_image_model("нарисуй девушку в стиле аниме") == "flux-anime"
-    assert bot._pick_image_model("draw a chibi character") == "flux-anime"
-
-
-def test_pick_image_model_detects_fantasy():
-    assert bot._pick_image_model("нарисуй дракона в фэнтезийном замке") == "dreamshaper"
-    assert bot._pick_image_model("concept art of an elf wizard") == "dreamshaper"
-
-
-def test_pick_image_model_detects_realism():
-    assert bot._pick_image_model("сделай фотореалистичный портрет кота") == "flux-realism"
-    assert bot._pick_image_model("realistic photo of a mountain") == "flux-realism"
-
-
-def test_pick_image_model_detects_quick_draft():
-    assert bot._pick_image_model("быстрый набросок логотипа") == "turbo"
-
-
-def test_pick_image_model_falls_back_to_default_for_generic_prompt():
-    assert bot._pick_image_model("космическая станция на орбите Земли") == bot.DEFAULT_POLLINATIONS_IMAGE_MODEL
-    assert bot._pick_image_model("") == bot.DEFAULT_POLLINATIONS_IMAGE_MODEL
-
-
-def test_pick_image_model_style_keyword_wins_over_quick_keyword():
-    # Стилевой сигнал важнее просьбы "побыстрее", если оба есть в одном промпте —
-    # см. докстринг _pick_image_model про порядок проверок.
-    assert bot._pick_image_model("быстро нарисуй аниме-девушку") == "flux-anime"
+@pytest.mark.parametrize(("prompt", "expected"), [
+    ("нарисуй девушку в стиле аниме", "flux-anime"),
+    ("draw a chibi character", "flux-anime"),
+    ("нарисуй дракона в фэнтезийном замке", "dreamshaper"),
+    ("concept art of an elf wizard", "dreamshaper"),
+    ("сделай фотореалистичный портрет кота", "flux-realism"),
+    ("realistic photo of a mountain", "flux-realism"),
+    ("быстрый набросок логотипа", "turbo"),
+    ("космическая станция на орбите Земли", bot.DEFAULT_POLLINATIONS_IMAGE_MODEL),
+    ("", bot.DEFAULT_POLLINATIONS_IMAGE_MODEL),
+    # Стилевой сигнал важнее просьбы "побыстрее" (порядок проверок в _pick_image_model).
+    ("быстро нарисуй аниме-девушку", "flux-anime"),
+])
+def test_pick_image_model(prompt, expected):
+    assert bot._pick_image_model(prompt) == expected
 
 
 def test_imgmodel_command_and_callback_removed():
@@ -786,40 +748,32 @@ def test_natural_language_trigger_consumes_one_slot(rate_guard_setup, text, hand
     assert len(lumen_limits.user_rate_limits[456]) == 1
 
 
-def test_match_pick_request_detects_taste_requests():
-    assert bot.match_pick_request("посоветуй фильм") == "film"
-    assert bot.match_pick_request("порекомендуй интересную книгу") == "books"
-    assert bot.match_pick_request("подскажи музыку для тренировки") == "music"
-    assert bot.match_pick_request("накидай сериалов") == "series"
-    assert bot.match_pick_request("придумай игру для компании") == "games"
+@pytest.mark.parametrize(("text", "expected"), [
+    ("посоветуй фильм", "film"),
+    ("порекомендуй интересную книгу", "books"),
+    ("подскажи музыку для тренировки", "music"),
+    ("накидай сериалов", "series"),
+    ("придумай игру для компании", "games"),
     # Английские запросы — тот же детектор (дефолтный язык бота — en).
-    assert bot.match_pick_request("recommend a movie") == "film"
-    assert bot.match_pick_request("suggest music for training") == "music"
-
-
-def test_match_pick_request_rejects_detailed_or_unrelated():
+    ("recommend a movie", "film"),
+    ("suggest music for training", "music"),
+    # Существительные и инфинитивы по-прежнему ведут в games.
+    ("посоветуй игры", "games"),
+    ("посоветуй во что поиграть", "games"),
     # Длинный запрос с деталями — обычным путём в модель, без кнопок.
-    assert bot.match_pick_request("посоветуй фильм про космос, ужасы, 2024 год, длинный список") is None
-    assert bot.match_pick_request("привет, как дела?") is None
-    assert bot.match_pick_request("нарисуй кота") is None
-    assert bot.match_pick_request("") is None
+    ("посоветуй фильм про космос, ужасы, 2024 год, длинны�� список", None),
+    ("привет, как дела?", None),
+    ("нарисуй кота", None),
+    ("", None),
     # Латиница — только по границам слов: "notebook" — не книги.
-    assert bot.match_pick_request("recommend a notebook") is None
-    # Кириллица — по началу слова: "тигр" — не игры (AUD-E-006), "игру" — игры.
-    assert bot.match_pick_request("посоветуй тигра") is None
-    assert bot.match_pick_request("придумай игру для компании") == "games"
-
-
-def test_match_pick_request_rejects_verb_forms_of_igrat():
-    # Аудит A6-6: префикс "игр" ловил глаголы — "кто играет" не запрос игры.
-    assert bot.match_pick_request("посоветуй кто играет сегодня") is None
-
-
-def test_match_pick_request_accepts_game_nouns_and_infinitives():
-    # Сторож: существительные и инфинитивы по-прежнему ведут в games.
-    assert bot.match_pick_request("придумай игру для компании") == "games"
-    assert bot.match_pick_request("посоветуй игры") == "games"
-    assert bot.match_pick_request("посоветуй во что поиграть") == "games"
+    ("recommend a notebook", None),
+    # Кириллица — по началу слова: "тигр" — не игры (AUD-E-006).
+    ("посоветуй тигра", None),
+    # Префикс "игр" не ловит глаголы: "кто играет" — не запрос игры.
+    ("посоветуй кто играет сегодня", None),
+])
+def test_match_pick_request(text, expected):
+    assert bot.match_pick_request(text) == expected
 
 
 def test_pick_question_sent_instead_of_ai_route(rate_guard_setup, monkeypatch):

tests/test_bot_routes.py

@@ -20,40 +20,25 @@ from tests.bot_test_helpers import (
 )
 
 
-def test_classify_model_error_rate_limit_by_status():
-    assert bot._classify_model_error(429, "") == "rate_limit"
-
-
-def test_classify_model_error_rate_limit_by_text():
-    assert bot._classify_model_error(None, "quota exceeded") == "rate_limit"
-
-
-def test_classify_model_error_paid():
-    assert bot._classify_model_error(402, "") == "paid"
-
-
-def test_classify_model_error_forbidden():
-    assert bot._classify_model_error(403, "") == "forbidden"
-
-
-def test_classify_model_error_unavailable():
-    assert bot._classify_model_error(404, "") == "unavailable"
-
-
-def test_classify_model_error_other_for_unknown():
-    assert bot._classify_model_error(500, "some random error") == "other"
-
-
-def test_next_fallback_model_skips_tried():
-    assert bot._next_fallback_model({"a"}, ["a", "b", "c"]) == "b"
-
-
-def test_next_fallback_model_all_tried_returns_none():
-    assert bot._next_fallback_model({"a", "b", "c"}, ["a", "b", "c"]) is None
+@pytest.mark.parametrize(("status", "text", "expected"), [
+    (429, "", "rate_limit"),
+    (None, "quota exceeded", "rate_limit"),
+    (402, "", "paid"),
+    (403, "", "forbidden"),
+    (404, "", "unavailable"),
+    (500, "some random error", "other"),
+])
+def test_classify_model_error(status, text, expected):
+    assert bot._classify_model_error(status, text) == expected
 
 
-def test_next_fallback_model_none_tried_returns_first():
-    assert bot._next_fallback_model(set(), ["a", "b", "c"]) == "a"
+@pytest.mark.parametrize(("tried", "chain", "expected"), [
+    ({"a"}, ["a", "b", "c"], "b"),
+    ({"a", "b", "c"}, ["a", "b", "c"], None),
+    (set(), ["a", "b", "c"], "a"),
+])
+def test_next_fallback_model(tried, chain, expected):
+    assert bot._next_fallback_model(tried, chain) == expected
 
 
 def test_error_status_reads_status_code_attribute():
@@ -211,13 +196,11 @@ def test_ask_gemini_scrubs_identity_leak_before_storing_history():
         bot.chat_state.pop(chat_id, None)
 
 
-def test_ask_openrouter_text_empty_model_chain_fallback_is_not_dead_model():
+@pytest.mark.parametrize("mode", ["text", "vision"])
+def test_empty_model_chain_falls_back_to_current_order_head(mode):
     # РЕГРЕССИЯ (24.07.2026): раньше запасным вариантом на случай пустого model_chain
-    # в ask_openrouter_text было "meta-llama/llama-3.3-70b-instruct:free" — та же
-    # модель, что подтверждённо снята провайдером с бесплатного тира (см. README,
-    # HTTP 404 "unavailable for free") и по этой же причине уже исключена из
-    # _OR_LIGHT_ORDER/_OR_HEAVY_ORDER. Проверяем, что дефолт теперь ссылается на
-    # актуальный _OR_LIGHT_ORDER, а не на захардкоженную мёртвую модель.
+    # стоял захардкоженный литерал мёртвой модели; теперь дефолт ссылается на голову
+    # актуального ORDER-списка (_OR_LIGHT_ORDER для текста, _OR_VISION_ORDER для vision).
     chat_id = 999401
 
     calls = []
@@ -229,8 +212,13 @@ def test_ask_openrouter_text_empty_model_chain_fallback_is_not_dead_model():
     original = bot._or_chat_completion_with_fallback
     bot._or_chat_completion_with_fallback = fake_or_fallback
     try:
-        asyncio.run(bot.ask_openrouter_text(chat_id, "привет", model_chain=[]))
-        assert calls[0] == [bot._OR_LIGHT_ORDER[0]]
+        if mode == "text":
+            asyncio.run(bot.ask_openrouter_text(chat_id, "привет", model_chain=[]))
+            expected = [bot._OR_LIGHT_ORDER[0]]
+        else:
+            asyncio.run(bot.ask_openrouter_multimodal(chat_id, "привет", (b"fake", "image/jpeg"), "photo.jpg", model_chain=[]))
+            expected = [bot._OR_VISION_ORDER[0]]
+        assert calls[0] == expected
         assert "meta-llama/llama-3.3-70b-instruct:free" not in calls[0]
     finally:
         bot._or_chat_completion_with_fallback = original
@@ -388,15 +376,20 @@ def test_extract_gemini_answer_reports_non_malformed_block_without_retry_state()
     assert "SAFETY" in ans
 
 
-def test_extract_gemini_answer_falls_through_when_retry_raises():
-    # Повтор после битого вызова сам упал (а не просто не влез в бюджет) — тоже
-    # отдаём пусто, чтобы маршрут ушёл на следующую модель. Раньше пользователь
-    # получал "[Ответ заблокирован...]" как готовый ответ и цепочка вставала.
+@pytest.mark.parametrize("retry_outcome", ["raises", "empty"])
+def test_extract_gemini_answer_failed_retry_goes_to_next_model(retry_outcome):
+    # Повтор после битого вызова сам упал (а не просто не влез в бюджет) или
+    # вернул пусто — отдаём п��сто, чтобы маршрут ушёл на следующую модель.
+    # Раньше пользователь получал "[Ответ заблокирован...]" как готовый ответ.
     async def retry_raises(*, model, contents, config=None):
         raise RuntimeError("transient 500 on retry")
 
+    async def retry_empty(*, model, contents, config=None):
+        return _FakeGeminiResponse(text="", candidates=[])
+
+    retry_fn = retry_raises if retry_outcome == "raises" else retry_empty
     fake_client = MagicMock()
-    fake_client.aio.models.generate_content = retry_raises
+    fake_client.aio.models.generate_content = retry_fn
     original_client = bot.client
     bot.client = fake_client
     try:
@@ -556,28 +549,6 @@ def test_ask_gemini_attempt_respects_short_budget(monkeypatch):
         bot.chat_state.pop(chat_id, None)
 
 
-def test_gemini_spent_budget_does_not_pretend_blocked(monkeypatch):
-    # Регрессия (враждебное ревью 27.09.2026): когда повтор после битого вызова не
-    # влезал в бюджет, функция возвращала непустую строку "[Ответ заблокирован...]",
-    # ask_gemini считал её успехом и юзер получал её вместо ответа следующей модели.
-    async def must_not_run(*, model, contents, config=None):
-        raise AssertionError("retry must not run on a spent budget")
-
-    fake_client = MagicMock()
-    fake_client.aio.models.generate_content = must_not_run
-    original_client = bot.client
-    bot.client = fake_client
-    try:
-        resp = _FakeGeminiResponse(text="", candidates=[_FakeCandidate(finish_reason="MALFORMED_FUNCTION_CALL")])
-        ans = asyncio.run(bot._extract_gemini_answer_text(
-            resp, model_id="gemini-3.8-flash", call_contents=[], gconfig=None,
-            deadline=time.monotonic() - 1.0,
-        ))
-        assert ans == "", "пустой ответ должен уводить маршрут на следующую модель"
-    finally:
-        bot.client = original_client
-
-
 def test_is_gemini_daily_quota_recognizes_google_per_day_metric():
     # Google пишет суточную квоту слитно в имени метрики
     # (GenerateRequestsPerDayPerProjectPerModel) — без токена perday она
@@ -1004,32 +975,14 @@ def test_ask_gemini_raises_when_route_budget_exceeded():
         bot.chat_state.pop(chat_id, None)
 
 
-def test_or_chat_completion_with_fallback_switches_model_on_rate_limit():
-    async def fake_or_request(path, method="GET", *, json_body=None, deadline=None):
-        model = json_body["model"]
-        if model == "model-a":
-            raise bot.OpenRouterAPIError("rate limit exceeded", status_code=429)
-        return {"choices": [{"message": {"content": "ответ от model-b"}}]}
-
-    original = bot._or_request
-    bot._or_request = fake_or_request
-    try:
-        messages = [{"role": "system", "content": "sys"}, {"role": "user", "content": "hi"}]
-        answer, used = asyncio.run(bot._or_chat_completion_with_fallback(messages, ["model-a", "model-b"], "model-a"))
-        assert answer == "ответ от model-b"
-        assert used == "model-b"
-    finally:
-        bot._or_request = original
-
-
-def test_or_chat_completion_with_fallback_switches_model_on_permanent_looking_error():
-    # Даже "постоянная" на вид ошибка (403 forbidden) не должна обрывать переход
-    # к следующей модели — при attempts_per_model=1 переход к следующей модели
-    # происходит независимо от классификации (см. комментарий в самой функции).
+@pytest.mark.parametrize(("status_code", "message"), [(429, "rate limit exceeded"), (403, "forbidden")])
+def test_or_chat_completion_with_fallback_switches_model(status_code, message):
+    # И минутный 429, и "постоянная" на вид 403 не обрывают переход к следующей
+    # модели: при attempts_per_model=1 переход происходит независимо от классификации.
     async def fake_or_request(path, method="GET", *, json_body=None, deadline=None):
         model = json_body["model"]
         if model == "model-a":
-            raise bot.OpenRouterAPIError("forbidden", status_code=403)
+            raise bot.OpenRouterAPIError(message, status_code=status_code)
         return {"choices": [{"message": {"content": "ответ от model-b"}}]}
 
     original = bot._or_request
@@ -1043,28 +996,6 @@ def test_or_chat_completion_with_fallback_switches_model_on_permanent_looking_er
         bot._or_request = original
 
 
-def test_ask_openrouter_multimodal_empty_model_chain_fallback_is_current_vision_order():
-    # РЕГРЕССИЯ (аудит техдолга): раньше здесь стоял захардкоженный литерал
-    # "nvidia/nemotron-nano-12b-v2-vl:free" — тот же класс бага, что уже был найден
-    # и исправлен в ask_openrouter_text (см. test_ask_openrouter_text_empty_model_chain_
-    # fallback_is_not_dead_model выше). Теперь дефолт ссылается на _OR_VISION_ORDER[0].
-    chat_id = 999410
-    calls = []
-
-    async def fake_or_fallback(messages, trial_models, primary_model_id, **kwargs):
-        calls.append(trial_models)
-        return "ответ", trial_models[0]
-
-    original = bot._or_chat_completion_with_fallback
-    bot._or_chat_completion_with_fallback = fake_or_fallback
-    try:
-        asyncio.run(bot.ask_openrouter_multimodal(chat_id, "привет", (b"fake", "image/jpeg"), "photo.jpg", model_chain=[]))
-        assert calls[0] == [bot._OR_VISION_ORDER[0]]
-    finally:
-        bot._or_chat_completion_with_fallback = original
-        bot.chat_state.pop(chat_id, None)
-
-
 def test_ask_openrouter_multimodal_sends_all_album_images_not_just_first():
     # Внешний аудит: уходила только первая фотография альбома, остальные 2–9 молча терялись.
     chat_id = 999411
@@ -1163,26 +1094,27 @@ def test_or_chat_completion_with_fallback_no_longer_accepts_attempts_per_model()
     assert "attempts_per_model" not in sig.parameters
 
 
-def test_or_request_scrubs_api_key_from_network_exception_message():
-    class _FakeSessionRaisingWithKeyInMessage:
+@pytest.mark.parametrize(("request_name", "key_attr", "fake_key", "error_cls"), [
+    ("_or_request", "OPENROUTER_API_KEY", "fake-secret-or-key-123", "OpenRouterAPIError"),
+    ("_groq_request", "GROQ_API_KEY", "fake-groq-key-123", "GroqAPIError"),
+])
+def test_provider_request_scrubs_api_key_from_network_exception_message(
+    monkeypatch, request_name, key_attr, fake_key, error_cls,
+):
+    # Defense-in-depth у обоих провайдеров: ключ не светится в тексте ошибок.
+    class _FakeSessionRaisingWithKey:
         def request(self, *args, **kwargs):
-            raise RuntimeError("connection failed, headers were: Authorization: Bearer fake-secret-or-key-123")
+            raise RuntimeError(f"connection failed, headers: Bearer {fake_key}")
 
     async def fake_get_http_session():
-        return _FakeSessionRaisingWithKeyInMessage()
+        return _FakeSessionRaisingWithKey()
 
-    original_get_session = bot._get_http_session
-    original_key = bot.OPENROUTER_API_KEY
-    bot._get_http_session = fake_get_http_session
-    bot.OPENROUTER_API_KEY = "fake-secret-or-key-123"
-    try:
-        with pytest.raises(bot.OpenRouterAPIError) as exc_info:
-            asyncio.run(bot._or_request("chat/completions", "POST", json_body={"model": "x"}))
-        assert "fake-secret-or-key-123" not in str(exc_info.value)
-        assert "<KEY>" in str(exc_info.value)
-    finally:
-        bot._get_http_session = original_get_session
-        bot.OPENROUTER_API_KEY = original_key
+    monkeypatch.setattr(bot, "_get_http_session", fake_get_http_session)
+    monkeypatch.setattr(bot, key_attr, fake_key)
+    with pytest.raises(getattr(bot, error_cls)) as exc_info:
+        asyncio.run(getattr(bot, request_name)("chat/completions", "POST", json_body={"model": "x"}))
+    assert fake_key not in str(exc_info.value)
+    assert "<KEY>" in str(exc_info.value)
 
 
 def test_probe_or_model_liveness_warns_on_dead_model_pattern(caplog):
@@ -1393,23 +1325,6 @@ def test_groq_request_requires_key(monkeypatch):
         asyncio.run(bot._groq_request("chat/completions", "POST", json_body={"model": "x"}))
 
 
-def test_groq_request_scrubs_api_key_from_network_exception_message(monkeypatch):
-    # Тот же defense-in-depth, что у _or_request: ключ не должен светиться в тексте ошибок.
-    class _FakeSessionRaisingWithKey:
-        def request(self, *args, **kwargs):
-            raise RuntimeError("connection failed, headers: Bearer fake-groq-key-123")
-
-    async def fake_get_http_session():
-        return _FakeSessionRaisingWithKey()
-
-    monkeypatch.setattr(bot, "_get_http_session", fake_get_http_session)
-    monkeypatch.setattr(bot, "GROQ_API_KEY", "fake-groq-key-123")
-    with pytest.raises(bot.GroqAPIError) as exc_info:
-        asyncio.run(bot._groq_request("chat/completions", "POST", json_body={"model": "x"}))
-    assert "fake-groq-key-123" not in str(exc_info.value)
-    assert "<KEY>" in str(exc_info.value)
-
-
 def test_route_error_reply_text_maps_groq_error():
     # Ошибка Groq — пользовательский текст через общую классификацию, без сырого API.
     exc = bot.GroqAPIError("Rate limit reached", status_code=429)
@@ -1591,53 +1506,28 @@ def test_transcribe_audio_capped_by_own_limit(monkeypatch):
     assert captured["timeout"].total < bot.ROUTE_MODEL_TIMEOUT_SEC
 
 
-def test_ask_openrouter_text_trims_history_with_summary_not_silent_cut(monkeypatch):
+@pytest.mark.parametrize(("ask_name", "stub_name", "answer"), [
+    ("ask_openrouter_text", "_or_chat_completion_with_fallback", "ответ"),
+    ("ask_groq_text", "_groq_request", "ответ groq"),
+])
+def test_text_provider_trims_history_with_summary_not_silent_cut(monkeypatch, ask_name, stub_name, answer):
     # Аудит A4-05: история резалась молчаливым срезом вместо _trim_history с саммари.
     import lumen_chat_state
     from collections import deque
     chat_id = 999811
 
     async def fake_fallback(messages, trial_models, primary_model_id, **kwargs):
-        return "ответ", trial_models[0]
-
-    async def fake_summarize(text):
-        return "итог: погода и коты"
-
-    monkeypatch.setattr(bot, "_or_chat_completion_with_fallback", fake_fallback)
-    monkeypatch.setattr(lumen_chat_state, "_summarize_text", fake_summarize)
-    state = bot.get_state(chat_id)
-    state["history"] = [
-        {"role": "user" if i % 2 == 0 else "assistant", "content": f"сообщение {i}"}
-        for i in range(105)
-    ]
-    state["ctx"] = deque()
-    try:
-        asyncio.run(bot.ask_openrouter_text(chat_id, "новый вопрос", model_chain=["m1"]))
-        history = bot.chat_state[chat_id]["history"]
-        assert len(history) == 81
-        assert history[0]["content"].startswith("[Ранее в диалоге]")
-        assert "погода" in history[0]["content"]
-        assert history[-2:] == [
-            {"role": "user", "content": "новый вопрос"},
-            {"role": "assistant", "content": "ответ"},
-        ]
-    finally:
-        bot.chat_state.pop(chat_id, None)
-
-
-def test_ask_groq_text_trims_history_with_summary_not_silent_cut(monkeypatch):
-    # Тот же молчаливый срез жил в ask_groq_text — фиксим парой (аудит A4-05: везде _trim_history).
-    import lumen_chat_state
-    from collections import deque
-    chat_id = 999812
+        return answer, trial_models[0]
 
     async def fake_groq_request(path, method="GET", *, json_body=None, deadline=None):
-        return {"choices": [{"message": {"content": "ответ groq"}}]}
+        return {"choices": [{"message": {"content": answer}}]}
+
+    stubs = {"_or_chat_completion_with_fallback": fake_fallback, "_groq_request": fake_groq_request}
 
     async def fake_summarize(text):
         return "итог: погода и коты"
 
-    monkeypatch.setattr(bot, "_groq_request", fake_groq_request)
+    monkeypatch.setattr(bot, stub_name, stubs[stub_name])
     monkeypatch.setattr(lumen_chat_state, "_summarize_text", fake_summarize)
     state = bot.get_state(chat_id)
     state["history"] = [
@@ -1646,14 +1536,14 @@ def test_ask_groq_text_trims_history_with_summary_not_silent_cut(monkeypatch):
     ]
     state["ctx"] = deque()
     try:
-        asyncio.run(bot.ask_groq_text(chat_id, "новый вопрос", model_chain=["m1"]))
+        asyncio.run(getattr(bot, ask_name)(chat_id, "новый вопрос", model_chain=["m1"]))
         history = bot.chat_state[chat_id]["history"]
         assert len(history) == 81
         assert history[0]["content"].startswith("[Ранее в диалоге]")
         assert "погода" in history[0]["content"]
         assert history[-2:] == [
             {"role": "user", "content": "новый вопрос"},
-            {"role": "assistant", "content": "ответ groq"},
+            {"role": "assistant", "content": answer},
         ]
     finally:
         bot.chat_state.pop(chat_id, None)
@@ -1707,26 +1597,6 @@ def test_run_route_marks_unsupported_media_for_text_fallback(monkeypatch):
         bot.chat_state.pop(chat_id, None)
 
 
-def test_extract_gemini_answer_empty_retry_goes_to_next_model():
-    # Аудит A4-10: повтор прошёл, но вернул пусто без исчерпания бюджета — это
-    # повод на следующую модель, а не заглушка блокировки как успех.
-    async def retry_empty(*, model, contents, config=None):
-        return _FakeGeminiResponse(text="", candidates=[])
-
-    fake_client = MagicMock()
-    fake_client.aio.models.generate_content = retry_empty
-    original_client = bot.client
-    bot.client = fake_client
-    try:
-        resp = _FakeGeminiResponse(text="", candidates=[_FakeCandidate(finish_reason="MALFORMED_FUNCTION_CALL")])
-        ans = asyncio.run(bot._extract_gemini_answer_text(
-            resp, model_id="gemini-3.8-flash", call_contents=[], gconfig=None,
-        ))
-        assert ans == ""
-    finally:
-        bot.client = original_client
-
-
 def test_run_route_cleans_placeholder_on_cancel(monkeypatch):
     # Аудит A4-06: отмена посреди ответа оставляла "…" в чате навсегда.
     placeholder = _FakeSentMessage()
@@ -1904,18 +1774,21 @@ def test_daily_limit_denial_counted_and_refused(rate_guard_setup, monkeypatch):
     bot.chat_state.pop(123, None)
 
 
-def test_gemini_success_logs_token_usage_when_api_returns_it(caplog):
+@pytest.mark.parametrize("with_usage", [True, False])
+def test_gemini_success_logs_token_usage(caplog, with_usage):
     # Что защищает: единственную точку калибровки лимитов по логам для Gemini
     # (usage_metadata.prompt_token_count/candidates_token_count/total_token_count).
     # Регрессия: тихий дроп usage при рефакторинге ask_gemini — счётчики пропадут из
     # логов, лимиты не на чем калибровать. Старые тесты проверяют только текст/историю.
+    # Без usage от API строка [usage] не пишется, лог не засоряется пустышками.
     import logging
     from types import SimpleNamespace
     chat_id = 999901
 
     def fake_generate_content(*, model, contents, config=None):
         resp = _FakeGeminiResponse(text="Привет!")
-        resp.usage_metadata = SimpleNamespace(prompt_token_count=10, candidates_token_count=20, total_token_count=30)
+        if with_usage:
+            resp.usage_metadata = SimpleNamespace(prompt_token_count=10, candidates_token_count=20, total_token_count=30)
         return resp
 
     fake_client = MagicMock()
@@ -1927,33 +1800,13 @@ def test_gemini_success_logs_token_usage_when_api_returns_it(caplog):
             answer = asyncio.run(bot.ask_gemini(chat_id, "Привет"))
         assert answer == "Привет!"
         usage_lines = [r.getMessage() for r in caplog.records if r.getMessage().startswith("[usage]")]
-        assert len(usage_lines) == 1
-        line = usage_lines[0]
-        assert f"chat={chat_id}" in line and "provider=gemini" in line
-        assert "prompt=10" in line and "completion=20" in line and "total=30" in line
-    finally:
-        bot.client = original_client
-        bot.chat_state.pop(chat_id, None)
-        caplog.clear()
-
-
-def test_gemini_success_logs_no_usage_line_without_metadata(caplog):
-    # Пара к предыдущему: если API usage не вернуло — строка [usage] не пишется,
-    # лог не засоряется пустышками. Старые тесты такого не проверяют.
-    import logging
-    chat_id = 999902
-
-    def fake_generate_content(*, model, contents, config=None):
-        return _FakeGeminiResponse(text="Привет!")
-
-    fake_client = MagicMock()
-    fake_client.aio.models.generate_content = AsyncMock(side_effect=fake_generate_content)
-    original_client = bot.client
-    bot.client = fake_client
-    try:
-        with caplog.at_level(logging.INFO, logger="bot"):
-            asyncio.run(bot.ask_gemini(chat_id, "Привет"))
-        assert not [r for r in caplog.records if r.getMessage().startswith("[usage]")]
+        if with_usage:
+            assert len(usage_lines) == 1
+            line = usage_lines[0]
+            assert f"chat={chat_id}" in line and "provider=gemini" in line
+            assert "prompt=10" in line and "completion=20" in line and "total=30" in line
+        else:
+            assert usage_lines == []
     finally:
         bot.client = original_client
         bot.chat_state.pop(chat_id, None)

tests/test_bot_state.py

@@ -50,31 +50,15 @@ def test_split_text_chunks_preserves_all_words():
     assert " ".join(chunks).split() == text.split()
 
 
-def test_split_text_chunks_lives_in_formatting_module():
-    # Срез монолита (сентябрь 2026): реализация — в lumen_formatting, bot.py
-    # только ре-экспортирует имя, чтобы bot._split_text_chunks работал как раньше.
-    import lumen_formatting
-    assert bot._split_text_chunks is lumen_formatting._split_text_chunks
-
-
-def test_sanitize_mime_type_guesses_from_extension():
-    assert bot._sanitize_mime_type("photo.jpg", "") == "image/jpeg"
-
-
-def test_sanitize_mime_type_lowercases_valid_mime():
-    assert bot._sanitize_mime_type(None, "image/PNG") == "image/png"
-
-
-def test_sanitize_mime_type_octet_stream_falls_back_to_extension():
-    assert bot._sanitize_mime_type("file.pdf", "application/octet-stream") == "application/pdf"
-
-
-def test_sanitize_mime_type_no_info_returns_default_fallback():
-    assert bot._sanitize_mime_type(None, None) == "application/octet-stream"
-
-
-def test_sanitize_mime_type_audio_ogg_passthrough():
-    assert bot._sanitize_mime_type(None, "audio/ogg") == "audio/ogg"
+@pytest.mark.parametrize(("filename", "mime", "expected"), [
+    ("photo.jpg", "", "image/jpeg"),
+    (None, "image/PNG", "image/png"),
+    ("file.pdf", "application/octet-stream", "application/pdf"),
+    (None, None, "application/octet-stream"),
+    (None, "audio/ogg", "audio/ogg"),
+])
+def test_sanitize_mime_type(filename, mime, expected):
+    assert bot._sanitize_mime_type(filename, mime) == expected
 
 
 def test_sanitize_mime_type_maps_containers_to_supported_mimes():
@@ -104,35 +88,27 @@ def test_ensure_prompt_text_gif_gets_animation_prompt_not_generic_image():
     assert "картинке" in bot._ensure_prompt_text(None, "image/jpeg")
 
 
-def test_is_tiktok_true_for_tiktok_url():
-    assert bot.is_tiktok("https://www.tiktok.com/@user/video/123") is True
-
-
-def test_is_tiktok_false_for_other_url():
-    assert bot.is_tiktok("https://youtube.com/watch?v=1") is False
-
-
-def test_is_youtube_true_for_short_link():
-    assert bot.is_youtube("https://youtu.be/abc123") is True
-
-
-def test_is_youtube_false_for_other_url():
-    assert bot.is_youtube("https://example.com") is False
-
-
-def test_extract_url_strips_trailing_punctuation():
-    assert bot.extract_url("check this out: https://example.com/page.") == "https://example.com/page"
+@pytest.mark.parametrize(("url", "is_tiktok", "is_youtube"), [
+    ("https://www.tiktok.com/@user/video/123", True, False),
+    ("https://youtube.com/watch?v=1", False, True),
+    ("https://youtu.be/abc123", False, True),
+    ("https://example.com", False, False),
+])
+def test_is_tiktok_and_is_youtube(url, is_tiktok, is_youtube):
+    assert bot.is_tiktok(url) is is_tiktok
+    assert bot.is_youtube(url) is is_youtube
 
 
-def test_extract_url_returns_none_when_no_url():
-    assert bot.extract_url("no url here") is None
+@pytest.mark.parametrize(("text", "expected"), [
+    ("check this out: https://example.com/page.", "https://example.com/page"),
+    ("no url here", None),
+])
+def test_extract_url(text, expected):
+    assert bot.extract_url(text) == expected
 
 
-def test_clean_mention_removes_username():
+def test_clean_mention():
     assert bot.clean_mention(f"@{bot.BOT_USERNAME} привет") == "привет"
-
-
-def test_clean_mention_is_case_insensitive():
     result = bot.clean_mention(f"привет @{bot.BOT_USERNAME.upper()} как дела")
     assert bot.BOT_USERNAME.lower() not in result.lower()
 
@@ -669,27 +645,25 @@ def test_sentry_not_initialized_without_dsn_in_test_env():
     assert sentry_sdk.is_initialized() is False
 
 
-def test_setup_logging_respects_log_level_env(monkeypatch):
-    # РЕГРЕССИЯ: раньше уровень был захардкожен INFO везде (root + оба handler'а) —
-    # log.debug(...) не печатался ни при каком окружении. LOG_LEVEL теперь читается
-    # так же, как и любой другой тюнинг в проекте.
+@pytest.mark.parametrize(("log_level", "expected"), [
+    # Регрессия: уровень был захардкожен INFO — log.debug не печатался ни при каком окружении.
+    ("DEBUG", "DEBUG"),
+    (None, "INFO"),
+])
+def test_setup_logging_level(monkeypatch, log_level, expected):
     import logging as _logging
-    monkeypatch.setenv("LOG_LEVEL", "DEBUG")
+    if log_level is None:
+        monkeypatch.delenv("LOG_LEVEL", raising=False)
+    else:
+        monkeypatch.setenv("LOG_LEVEL", log_level)
     try:
         bot._setup_logging()
-        assert _logging.getLogger().level == _logging.DEBUG
+        assert _logging.getLogger().level == getattr(_logging, expected)
     finally:
         monkeypatch.delenv("LOG_LEVEL", raising=False)
         bot._setup_logging()  # восстановить дефолт INFO для остальных тестов
 
 
-def test_setup_logging_defaults_to_info_when_unset(monkeypatch):
-    import logging as _logging
-    monkeypatch.delenv("LOG_LEVEL", raising=False)
-    bot._setup_logging()
-    assert _logging.getLogger().level == _logging.INFO
-
-
 def test_setup_logging_uses_bot_logger_name_not_dunder_main():
     # РЕГРЕССИЯ (аудит логирования): _setup_logging() раньше возвращал
     # logging.getLogger(__name__) — "bot" при import bot (как в тестах), но
@@ -1895,28 +1869,21 @@ def test_reject_rate_limited_message_does_not_create_chat_state(monkeypatch):
         bot.chat_state.pop(chat_id, None)
 
 
-def test_rate_limit_key_for_message_uses_from_user_when_present():
-    msg = SimpleNamespace(
-        from_user=SimpleNamespace(id=555), sender_chat=None,
-        chat=SimpleNamespace(id=-100999),
-    )
-    assert bot._rate_limit_key_for_message(msg) == 555
-
-
-def test_rate_limit_key_for_message_falls_back_to_sender_chat_without_from_user():
+@pytest.mark.parametrize(("from_user_id", "sender_chat_id", "expected"), [
+    (555, None, 555),
     # Сообщение "от имени канала" — from_user отсутствует, но есть sender_chat.
+    (None, -100777, -100777),
+    # Ни from_user, ни sender_chat — сам chat.id, лишь бы не None (иначе
+    # отправитель полностью нелимитирован).
+    (None, None, -100999),
+])
+def test_rate_limit_key_for_message(from_user_id, sender_chat_id, expected):
     msg = SimpleNamespace(
-        from_user=None, sender_chat=SimpleNamespace(id=-100777),
+        from_user=SimpleNamespace(id=from_user_id) if from_user_id is not None else None,
+        sender_chat=SimpleNamespace(id=sender_chat_id) if sender_chat_id is not None else None,
         chat=SimpleNamespace(id=-100999),
     )
-    assert bot._rate_limit_key_for_message(msg) == -100777
-
-
-def test_rate_limit_key_for_message_falls_back_to_chat_id_as_last_resort():
-    # Ни from_user, ни sender_chat — берём сам chat.id, лишь бы не None (регрессия
-    # на сам факт обхода: раньше это давало полностью нелимитированного отправителя).
-    msg = SimpleNamespace(from_user=None, sender_chat=None, chat=SimpleNamespace(id=-100999))
-    assert bot._rate_limit_key_for_message(msg) == -100999
+    assert bot._rate_limit_key_for_message(msg) == expected
 
 
 def test_rate_limit_key_for_message_never_falls_through_to_none():
@@ -1930,23 +1897,19 @@ def test_rate_limit_key_for_message_never_falls_through_to_none():
         assert key is not None and key != 0
 
 
-def test_should_only_record_passively_true_for_unmentioned_group_text():
-    msg = _FakeIncomingMessage(1)
-    assert bot._should_only_record_passively(msg, "привет всем", is_private=False, is_guest=False, mentioned=False) is True
-
-
-def test_should_only_record_passively_false_when_mentioned_or_private_or_guest():
-    msg = _FakeIncomingMessage(1)
-    assert bot._should_only_record_passively(msg, "привет", is_private=True, is_guest=False, mentioned=False) is False
-    assert bot._should_only_record_passively(msg, "привет", is_private=False, is_guest=True, mentioned=False) is False
-    assert bot._should_only_record_passively(msg, "привет", is_private=False, is_guest=False, mentioned=True) is False
-
-
-def test_should_only_record_passively_false_for_tiktok_link_without_mention():
+@pytest.mark.parametrize(("text", "is_private", "is_guest", "mentioned", "expected"), [
+    ("привет всем", False, False, False, True),
+    ("привет", True, False, False, False),
+    ("привет", False, True, False, False),
+    ("привет", False, False, True, False),
     # TikTok-ссылка обрабатывается всегда, даже без упоминания бота в группе.
+    ("гляньте https://www.tiktok.com/@user/video/123", False, False, False, False),
+])
+def test_should_only_record_passively(text, is_private, is_guest, mentioned, expected):
     msg = _FakeIncomingMessage(1)
-    text = "гляньте https://www.tiktok.com/@user/video/123"
-    assert bot._should_only_record_passively(msg, text, is_private=False, is_guest=False, mentioned=False) is False
+    assert bot._should_only_record_passively(
+        msg, text, is_private=is_private, is_guest=is_guest, mentioned=mentioned,
+    ) is expected
 
 
 def test_handle_message_core_known_route_outcome_logs_as_warning_not_exception(caplog):

tests/test_bot_tiktok.py

@@ -103,110 +103,56 @@ def test_tiktok_video_candidates_empty_when_nothing_available():
     assert bot._tiktok_video_candidates({}) == []
 
 
-def test_original_sound_label_russian():
-    assert bot._original_sound_label("ru") == "Оригинальный звук"
-
-
-def test_original_sound_label_ukrainian():
-    assert bot._original_sound_label("uk") == "Оригінальний звук"
-
-
-def test_original_sound_label_belarusian():
-    assert bot._original_sound_label("be") == "Арыгінальны гук"
-
-
-def test_original_sound_label_english():
-    assert bot._original_sound_label("en") == "Original sound"
-
-
-def test_original_sound_label_strips_region_subtag():
-    # Telegram может прислать региональный вариант ("en-US", "pt-BR") — берём
-    # только первичный языковой подтег до дефиса.
-    assert bot._original_sound_label("en-US") == "Original sound"
-    assert bot._original_sound_label("pt-BR") == "Som original"
-
-
-def test_original_sound_label_falls_back_to_english_for_unknown_code():
-    assert bot._original_sound_label("sw") == "Original sound"
-    assert bot._original_sound_label("xx-YY") == "Original sound"
-
-
-def test_original_sound_label_falls_back_to_english_when_missing():
-    assert bot._original_sound_label(None) == "Original sound"
-    assert bot._original_sound_label("") == "Original sound"
-
-
-def test_original_sound_label_case_insensitive():
-    assert bot._original_sound_label("RU") == "Оригинальный звук"
-
-
-def test_original_sound_label_fallback_chain():
+@pytest.mark.parametrize(("user_lang", "chat_lang", "expected"), [
+    ("ru", None, "Оригинальный звук"),
+    ("uk", None, "Оригінальний звук"),
+    ("be", None, "Арыгінальны гук"),
+    ("en", None, "Original sound"),
+    # Telegram присылает региональный вариант ("en-US", "pt-BR") — только первичный подтег.
+    ("en-US", None, "Original sound"),
+    ("pt-BR", None, "Som original"),
+    ("sw", None, "Original sound"),
+    ("xx-YY", None, "Original sound"),
+    (None, None, "Original sound"),
+    ("", None, "Original sound"),
+    ("RU", None, "Оригинальный звук"),
     # Цепочка: язык отправителя → язык чата (/lang) → английский.
-    assert bot._original_sound_label("de", "uk") == "Originalton"
-    assert bot._original_sound_label(None, "uk") == "Оригінальний звук"
-    assert bot._original_sound_label("sw", "kk") == "Түпнұсқа дыбыс"
-    assert bot._original_sound_label("th", "kk") == "เสียงต้นฉบับ"
-    assert bot._original_sound_label("sw", "xx") == "Original sound"
-    assert bot._original_sound_label(None, None) == "Original sound"
-
-
-def test_tiktok_music_page_id_extracts_trailing_numeric_id():
-    url = "https://www.tiktok.com/music/original-sound-7666630127215823637"
-    assert bot._tiktok_music_page_id(url) == "7666630127215823637"
-
-
-def test_tiktok_music_page_id_extracts_id_with_cyrillic_slug():
-    # Реальный найденный в логах случай — слаг на русском языке.
-    url = "https://www.tiktok.com/music/оригинальный-звук-7667114246303812385"
-    assert bot._tiktok_music_page_id(url) == "7667114246303812385"
-
-
-def test_tiktok_music_page_id_handles_trailing_slash():
-    url = "https://www.tiktok.com/music/original-sound-7666630127215823637/"
-    assert bot._tiktok_music_page_id(url) == "7666630127215823637"
-
-
-def test_tiktok_music_page_id_none_for_regular_video_link():
-    url = "https://www.tiktok.com/@someuser/video/7370000000000000001"
-    assert bot._tiktok_music_page_id(url) is None
-
-
-def test_tiktok_music_page_id_none_for_photo_post_link():
-    url = "https://www.tiktok.com/@someuser/photo/7370000000000000002"
-    assert bot._tiktok_music_page_id(url) is None
-
-
-def test_tiktok_music_page_id_none_for_named_track_slug():
-    # Именованные треки/песни тоже используют /music/, просто со своим слагом —
-    # функция всё равно должна найти числовой ID (сама эвристика "сработает ли
-    # скачивание" находится не здесь, а в handle_tiktok_sound).
-    url = "https://www.tiktok.com/music/Blinding-Lights-6862178485109294850"
-    assert bot._tiktok_music_page_id(url) == "6862178485109294850"
-
-
-def test_looks_like_resolved_tiktok_url_true_for_proper_video_url():
-    assert bot._looks_like_resolved_tiktok_url("https://www.tiktok.com/@someuser/video/7370000000000000001") is True
-
-
-def test_looks_like_resolved_tiktok_url_true_for_proper_photo_url():
-    assert bot._looks_like_resolved_tiktok_url("https://www.tiktok.com/@someuser/photo/7370000000000000002") is True
-
-
-def test_looks_like_resolved_tiktok_url_false_for_empty_username():
-    # Точно тот URL, ч��о реально ушёл в TikWM и получил 403 в реальном инциденте.
-    assert bot._looks_like_resolved_tiktok_url("https://www.tiktok.com/@/photo/7512093374153772309") is False
-
-
-def test_looks_like_resolved_tiktok_url_false_for_bare_at_sign_without_post():
-    # Просто "@" где-то в строке (например голая страница профиля без поста, или
-    # случайное совпадение) — раньше проходило старую слабую проверку.
-    assert bot._looks_like_resolved_tiktok_url("https://www.tiktok.com/@someuser") is False
-    assert bot._looks_like_resolved_tiktok_url("https://www.tiktok.com/some-page?ref=@video") is False
-
-
-def test_looks_like_resolved_tiktok_url_false_for_empty_or_none():
-    assert bot._looks_like_resolved_tiktok_url("") is False
-    assert bot._looks_like_resolved_tiktok_url(None) is False
+    ("de", "uk", "Originalton"),
+    (None, "uk", "Оригінальний звук"),
+    ("sw", "kk", "Түпнұсқа дыбыс"),
+    ("th", "kk", "เสียงต้นฉบับ"),
+    ("sw", "xx", "Original sound"),
+])
+def test_original_sound_label(user_lang, chat_lang, expected):
+    assert bot._original_sound_label(user_lang, chat_lang) == expected
+
+
+@pytest.mark.parametrize(("url", "expected"), [
+    ("https://www.tiktok.com/music/original-sound-7666630127215823637", "7666630127215823637"),
+    # Реальный случай из логов — слаг на русском языке.
+    ("https://www.tiktok.com/music/оригинальный-звук-7667114246303812385", "7667114246303812385"),
+    ("https://www.tiktok.com/music/original-sound-7666630127215823637/", "7666630127215823637"),
+    ("https://www.tiktok.com/@someuser/video/7370000000000000001", None),
+    ("https://www.tiktok.com/@someuser/photo/7370000000000000002", None),
+    # Именованный трек со своим слагом — числовой ID всё равно находится.
+    ("https://www.tiktok.com/music/Blinding-Lights-6862178485109294850", "6862178485109294850"),
+])
+def test_tiktok_music_page_id(url, expected):
+    assert bot._tiktok_music_page_id(url) == expected
+
+
+@pytest.mark.parametrize(("url", "expected"), [
+    ("https://www.tiktok.com/@someuser/video/7370000000000000001", True),
+    ("https://www.tiktok.com/@someuser/photo/7370000000000000002", True),
+    # Тот URL с пустым юзернеймом, что реально ушёл в TikWM и получил 403.
+    ("https://www.tiktok.com/@/photo/7512093374153772309", False),
+    ("https://www.tiktok.com/@someuser", False),
+    ("https://www.tiktok.com/some-page?ref=@video", False),
+    ("", False),
+    (None, False),
+])
+def test_looks_like_resolved_tiktok_url(url, expected):
+    assert bot._looks_like_resolved_tiktok_url(url) is expected
 
 
 def test_resolve_tiktok_short_falls_through_to_get_when_head_gives_malformed_url():
@@ -243,99 +189,65 @@ def test_resolve_tiktok_short_returns_get_result_even_if_still_malformed():
     assert result == "https://www.tiktok.com/@/photo/999"
 
 
-def test_slideshow_slide_urls_prefers_live_images_when_present():
-    media_data = {"live_images": ["https://tikwm.com/live0.mp4", ""]}
-    images_to_fetch = ["https://tikwm.com/photo0.jpg", "https://tikwm.com/photo1.jpg"]
-    assert bot._slideshow_slide_urls(media_data, images_to_fetch) == [
-        "https://tikwm.com/live0.mp4", "https://tikwm.com/photo1.jpg",
-    ]
-
-
-def test_slideshow_slide_urls_falls_back_when_live_images_absent():
-    images_to_fetch = ["https://tikwm.com/photo0.jpg", "https://tikwm.com/photo1.jpg"]
-    assert bot._slideshow_slide_urls({}, images_to_fetch) == images_to_fetch
-
-
-def test_slideshow_slide_urls_falls_back_when_live_images_shorter():
-    media_data = {"live_images": ["https://tikwm.com/live0.mp4"]}
-    images_to_fetch = ["https://tikwm.com/photo0.jpg", "https://tikwm.com/photo1.jpg"]
-    assert bot._slideshow_slide_urls(media_data, images_to_fetch) == [
-        "https://tikwm.com/live0.mp4", "https://tikwm.com/photo1.jpg",
-    ]
-
-
-def test_slideshow_slide_urls_ignores_non_list_live_images():
-    media_data = {"live_images": "not-a-list"}
-    images_to_fetch = ["https://tikwm.com/photo0.jpg"]
-    assert bot._slideshow_slide_urls(media_data, images_to_fetch) == images_to_fetch
-
-
-def test_looks_like_video_bytes_true_for_mp4_ftyp_signature():
+@pytest.mark.parametrize(("media_data", "images", "expected"), [
+    (
+        {"live_images": ["https://tikwm.com/live0.mp4", ""]},
+        ["https://tikwm.com/photo0.jpg", "https://tikwm.com/photo1.jpg"],
+        ["https://tikwm.com/live0.mp4", "https://tikwm.com/photo1.jpg"],
+    ),
+    (
+        {},
+        ["https://tikwm.com/photo0.jpg", "https://tikwm.com/photo1.jpg"],
+        ["https://tikwm.com/photo0.jpg", "https://tikwm.com/photo1.jpg"],
+    ),
+    (
+        {"live_images": ["https://tikwm.com/live0.mp4"]},
+        ["https://tikwm.com/photo0.jpg", "https://tikwm.com/photo1.jpg"],
+        ["https://tikwm.com/live0.mp4", "https://tikwm.com/photo1.jpg"],
+    ),
+    (
+        {"live_images": "not-a-list"},
+        ["https://tikwm.com/photo0.jpg"],
+        ["https://tikwm.com/photo0.jpg"],
+    ),
+])
+def test_slideshow_slide_urls(media_data, images, expected):
+    assert bot._slideshow_slide_urls(media_data, images) == expected
+
+
+@pytest.mark.parametrize(("payload", "expected"), [
     # Реальная сигнатура начала MP4/MOV-контейнера: 4 байта размера бокса + "ftyp".
-    mp4_header = b"\x00\x00\x00\x18ftypmp42\x00\x00\x00\x00mp42isom"
-    assert bot._looks_like_video_bytes(mp4_header) is True
-
-
-def test_looks_like_video_bytes_false_for_jpeg():
-    jpeg_header = b"\xff\xd8\xff\xe0\x00\x10JFIF\x00\x01\x01\x00"
-    assert bot._looks_like_video_bytes(jpeg_header) is False
-
-
-def test_looks_like_video_bytes_false_for_png():
-    png_header = b"\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR"
-    assert bot._looks_like_video_bytes(png_header) is False
-
-
-def test_looks_like_video_bytes_false_for_too_short_input():
-    assert bot._looks_like_video_bytes(b"\x00\x00\x00\x18fty") is False
-
-
-def test_looks_like_video_bytes_false_for_empty_bytes():
-    assert bot._looks_like_video_bytes(b"") is False
-
-
-def test_chunk_tiktok_media_items_exact_multiple_of_ten():
-    items = list(range(20))
-    chunks = bot._chunk_tiktok_media_items(items)
-    assert [len(c) for c in chunks] == [10, 10]
-    assert sum(chunks, []) == items
-
-
-def test_chunk_tiktok_media_items_avoids_trailing_single_item_at_eleven():
-    items = list(range(11))
-    chunks = bot._chunk_tiktok_media_items(items)
-    assert [len(c) for c in chunks] == [9, 2]
-    for c in chunks:
-        assert 2 <= len(c) <= 10
-    assert sum(chunks, []) == items
-
-
-def test_chunk_tiktok_media_items_avoids_trailing_single_item_at_twenty_one():
-    items = list(range(21))
-    chunks = bot._chunk_tiktok_media_items(items)
-    assert [len(c) for c in chunks] == [10, 9, 2]
-    for c in chunks:
-        assert 2 <= len(c) <= 10
-    assert sum(chunks, []) == items
-
-
-def test_chunk_tiktok_media_items_avoids_trailing_single_item_at_tiktok_max_thirty_one():
-    items = list(range(31))
-    chunks = bot._chunk_tiktok_media_items(items)
-    for c in chunks:
-        assert 2 <= len(c) <= 10
-    assert sum(chunks, []) == items
-
-
-def test_chunk_tiktok_media_items_no_borrow_needed_at_thirty_five():
+    (b"\x00\x00\x00\x18ftypmp42\x00\x00\x00\x00mp42isom", True),
+    # A7-9: WebM-слайд раньше принимался за фото.
+    (b"\x1a\x45\xdf\xa3" + b"\x00" * 16, True),
+    (b"\xff\xd8\xff\xe0\x00\x10JFIF\x00\x01\x01\x00", False),
+    (b"\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR", False),
+    (b"\x00\x00\x00\x18fty", False),
+    (b"", False),
+])
+def test_looks_like_video_bytes(payload, expected):
+    assert bot._looks_like_video_bytes(payload) is expected
+
+
+@pytest.mark.parametrize(("n_items", "expected"), [
+    (20, [10, 10]),
+    (11, [9, 2]),
+    (21, [10, 9, 2]),
+    # Хвост-одиночка на максимуме TikTok недопустим, точный расклад не фиксируем.
+    (31, None),
     # Официальный максимум TikTok (35) кратен 10 с остатком 5 — переноса не требуется.
-    items = list(range(35))
+    (35, [10, 10, 10, 5]),
+    (0, []),
+])
+def test_chunk_tiktok_media_items(n_items, expected):
+    items = list(range(n_items))
     chunks = bot._chunk_tiktok_media_items(items)
-    assert [len(c) for c in chunks] == [10, 10, 10, 5]
-
-
-def test_chunk_tiktok_media_items_empty_list():
-    assert bot._chunk_tiktok_media_items([]) == []
+    if expected is not None:
+        assert [len(c) for c in chunks] == expected
+    else:
+        for c in chunks:
+            assert 2 <= len(c) <= 10
+    assert sum(chunks, []) == items
 
 
 def test_chunk_tiktok_media_items_single_item_not_split_further():
@@ -1621,11 +1533,6 @@ def test_tiktok_video_candidates_protocol_relative_url():
     assert candidates[0]["url"] == "https://cdn.tikwm.com/v.mp4"
 
 
-def test_looks_like_video_bytes_true_for_webm_ebml():
-    # A7-9: WebM-слайд раньше принимался за фото.
-    assert bot._looks_like_video_bytes(b"\x1a\x45\xdf\xa3" + b"\x00" * 16) is True
-
-
 def test_download_url_bin_honors_caller_cap():
     # Аудит A7-5: видео режем лимитом отправки (50МБ), а не общим 75МБ.
     mapping = {"http://8.8.8.8/v.mp4": _FakeDownloadResponse([b"123456789012345"])}

tests/test_bot_transport.py

@@ -26,21 +26,16 @@ def test_circuit_breaker_starts_closed():
     assert breaker.is_down(time.monotonic()) is False
 
 
-def test_circuit_breaker_does_not_trip_before_threshold():
+@pytest.mark.parametrize(("failures", "tripped"), [(2, False), (3, True)])
+def test_circuit_breaker_trip_threshold(failures, tripped):
     breaker = bot._TelegramProxyCircuitBreaker(cooldown_sec=20.0, trip_threshold=3)
-    assert breaker.note_failure() is False
-    assert breaker.note_failure() is False
-    assert breaker.is_down(time.monotonic()) is False
-
-
-def test_circuit_breaker_trips_at_threshold():
-    breaker = bot._TelegramProxyCircuitBreaker(cooldown_sec=20.0, trip_threshold=3)
-    breaker.note_failure()
-    breaker.note_failure()
-    tripped = breaker.note_failure()
-    assert tripped is True
-    breaker.trip()
-    assert breaker.is_down(time.monotonic()) is True
+    result = False
+    for _ in range(failures):
+        result = breaker.note_failure()
+    assert result is tripped
+    if tripped:
+        breaker.trip()
+    assert breaker.is_down(time.monotonic()) is tripped
 
 
 def test_circuit_breaker_success_resets_consecutive_failures():
@@ -152,40 +147,26 @@ def test_rotate_telegram_proxy_noop_with_single_candidate():
         bot._telegram_proxy_idx = original_idx
 
 
-def test_rotate_telegram_proxy_switches_and_reports_lap_not_done():
+@pytest.mark.parametrize(("start_idx", "expected_idx", "expected_switched", "expected_url"), [
+    # Ещё не замкнули круг — есть смысл пробовать сразу.
+    (0, 1, True, "https://fallback.example.com"),
+    # Уже на резервном — поворот вернёт на primary, круг замкнулся, пора пауза.
+    (1, 0, False, "https://primary.example.com"),
+])
+def test_rotate_telegram_proxy_advances_and_reports_lap(start_idx, expected_idx, expected_switched, expected_url):
     original_candidates = bot._TELEGRAM_PROXY_CANDIDATES
     original_idx = bot._telegram_proxy_idx
     original_base_url = bot.TELEGRAM_API_BASE_URL
     original_bot = bot.bot
     bot._TELEGRAM_PROXY_CANDIDATES = ["https://primary.example.com", "https://fallback.example.com"]
-    bot._telegram_proxy_idx = 0
-    bot.TELEGRAM_API_BASE_URL = "https://primary.example.com"
+    bot._telegram_proxy_idx = start_idx
+    bot.TELEGRAM_API_BASE_URL = "https://primary.example.com" if start_idx == 0 else "https://fallback.example.com"
     bot.bot = None  # без реального aiogram Bot — проверяем только URL-переключение
     try:
         switched = asyncio.run(bot._rotate_telegram_proxy())
-        assert switched is True  # ещё не замкнули круг — есть смысл пробовать сразу
-        assert bot.TELEGRAM_API_BASE_URL == "https://fallback.example.com"
-        assert bot._telegram_proxy_idx == 1
-    finally:
-        bot._TELEGRAM_PROXY_CANDIDATES = original_candidates
-        bot._telegram_proxy_idx = original_idx
-        bot.TELEGRAM_API_BASE_URL = original_base_url
-        bot.bot = original_bot
-
-
-def test_rotate_telegram_proxy_reports_lap_done_after_full_cycle():
-    original_candidates = bot._TELEGRAM_PROXY_CANDIDATES
-    original_idx = bot._telegram_proxy_idx
-    original_base_url = bot.TELEGRAM_API_BASE_URL
-    original_bot = bot.bot
-    bot._TELEGRAM_PROXY_CANDIDATES = ["https://primary.example.com", "https://fallback.example.com"]
-    bot._telegram_proxy_idx = 1  # уже на резервном — следующий поворот вернёт на primary (idx 0)
-    bot.TELEGRAM_API_BASE_URL = "https://fallback.example.com"
-    bot.bot = None
-    try:
-        switched = asyncio.run(bot._rotate_telegram_proxy())
-        assert switched is False  # круг замкнулся — пора паузу включать
-        assert bot._telegram_proxy_idx == 0
+        assert switched is expected_switched
+        assert bot._telegram_proxy_idx == expected_idx
+        assert bot.TELEGRAM_API_BASE_URL == expected_url
     finally:
         bot._TELEGRAM_PROXY_CANDIDATES = original_candidates
         bot._telegram_proxy_idx = original_idx

tests/test_lumen_formatting.py

@@ -14,10 +14,8 @@ Telegram/Gemini/OpenRouter/рантайм-состояния бота, поэт
 Запуск:
     pytest test_lumen_formatting.py -v
 """
-import inspect
-
 import lumen_formatting
-import lumen_streaming
+import pytest
 
 
 
@@ -37,20 +35,15 @@ def test_truncate_html_to_fit_keeps_short_text_and_cuts_at_source_boundary():
 
 # ─────────────────────────── _md_to_html ───────────────────────────
 
-def test_md_to_html_empty_string():
-    assert lumen_formatting._md_to_html("") == ""
-
-
-def test_md_to_html_bold():
-    assert lumen_formatting._md_to_html("**bold**") == "<b>bold</b>"
-
-
-def test_md_to_html_italic():
-    assert lumen_formatting._md_to_html("*italic*") == "<i>italic</i>"
-
-
-def test_md_to_html_strikethrough():
-    assert lumen_formatting._md_to_html("~~strike~~") == "<s>strike</s>"
+@pytest.mark.parametrize(("source", "expected"), [
+    ("", ""),
+    ("**bold**", "<b>bold</b>"),
+    ("*italic*", "<i>italic</i>"),
+    ("~~strike~~", "<s>strike</s>"),
+    ("`code`", "<code>code</code>"),
+])
+def test_md_to_html_basic_markup(source, expected):
+    assert lumen_formatting._md_to_html(source) == expected
 
 
 def test_md_to_html_escapes_raw_html():
@@ -64,10 +57,7 @@ def test_md_to_html_inline_code():
 
 
 def test_md_to_html_code_block():
-    # Язык фенса теперь сохраняется как class="language-x" (подсветка синтаксиса
-    # в Telegram) — см. test_md_to_html_code_block_preserves_language_for_syntax_
-    # highlighting ниже; без языка поведение как раньше (test_md_to_html_code_
-    # block_without_language_unchanged).
+    # Язык фенса сохраняется как class="language-x" для подсветки в Telegram.
     assert lumen_formatting._md_to_html("```python\nprint(1)\n```") == '<pre><code class="language-python">print(1)</code></pre>'
 
 
@@ -112,36 +102,30 @@ def test_md_to_html_still_escapes_ordinary_comparison_operators():
     assert lumen_formatting._md_to_html("сравнение: 5 < 10") == "сравнение: 5 &lt; 10"
 
 
-def test_md_to_html_converts_markdown_table_to_bullet_list():
-    # Регрессия на реальный найденный при тестировании баг: Telegram не рендерит
-    # markdown-таблицы НИ В КАКОМ режиме — пользователь видел сырой текст с "|" и
-    # "---" вместо аккуратной таблицы (подтверждено скриншотами реального теста).
-    text = (
+@pytest.mark.parametrize(("text", "present"), [
+    # Регрессия: Telegram не рендерит markdown-таблицы ни в каком режиме —
+    # пользователь видел сырой текст с "|" и "---" (подтверждено скриншотами).
+    (
         "| Аспект | React | Vue |\n"
         "|--------|-------|-----|\n"
         "| Кривая обучения | Высокая | Низкая |\n"
-        "| Сообщество | Огромное | Среднее |"
-    )
-    result = lumen_formatting._md_to_html(text)
-    assert "|" not in result
-    assert "<b>Аспект:</b> Кривая обучения" in result
-    assert "<b>React:</b> Высокая" in result
-    assert "<b>Vue:</b> Низкая" in result
-    assert result.count("•") == 2
-
-
-def test_md_to_html_table_without_outer_pipes_still_converted():
+        "| Сообщество | Огромное | Среднее |",
+        ("<b>Аспект:</b> Кривая обучения", "<b>React:</b> Высокая", "<b>Vue:</b> Низкая"),
+    ),
     # Некоторые модели пишут таблицы без внешних "|" по краям строки.
-    text = (
+    (
         "Название | Цена\n"
         "---|---\n"
         "Кофе | 150\n"
-        "Чай | 100"
-    )
+        "Чай | 100",
+        ("<b>Название:</b> Кофе", "<b>Цена:</b> 150"),
+    ),
+])
+def test_md_to_html_converts_markdown_tables_to_bullet_lists(text, present):
     result = lumen_formatting._md_to_html(text)
     assert "|" not in result
-    assert "<b>Название:</b> Кофе" in result
-    assert "<b>Цена:</b> 150" in result
+    assert all(p in result for p in present)
+    assert result.count("•") == 2
 
 
 def test_md_to_html_does_not_touch_pipes_inside_code_block():
@@ -166,22 +150,24 @@ def test_md_to_html_no_false_positive_on_plain_text_with_dashes():
 # выдала "\[ S = \pi r^{2}, \]" и "\(x^{2}+y^{2}=r^{2}\)" вместо юникода, несмотря на
 # явный запрет LaTeX в system_prompt.py.
 
-def test_scrub_latex_converts_bracket_delimiters_and_pi_and_superscript():
-    result = lumen_formatting._scrub_latex(r"Площадь: \[ S = \pi r^{2} \]")
-    assert "\\[" not in result and "\\]" not in result
-    assert "π" in result
-    assert "r²" in result
-
+@pytest.mark.parametrize(("source", "gone", "present"), [
+    (r"Площадь: \[ S = \pi r^{2} \]", ("\\[", "\\]"), ("π", "r²")),
+    (r"формула \(x^{2}+y^{2}=r^{2}\)", ("\\(", "\\)"), ("x²+y²=r²",)),
+])
+def test_scrub_latex_converts_delimited_math(source, gone, present):
+    result = lumen_formatting._scrub_latex(source)
+    assert all(g not in result for g in gone)
+    assert all(p in result for p in present)
 
-def test_scrub_latex_converts_paren_delimiters():
-    result = lumen_formatting._scrub_latex(r"формула \(x^{2}+y^{2}=r^{2}\)")
-    assert "\\(" not in result and "\\)" not in result
-    assert "x²+y²=r²" in result
 
-
-def test_scrub_latex_converts_frac_and_sqrt():
-    assert lumen_formatting._scrub_latex(r"\frac{1}{2}") == "1/2"
-    assert lumen_formatting._scrub_latex(r"\sqrt{16}") == "√16"
+@pytest.mark.parametrize(("source", "expected"), [
+    (r"\frac{1}{2}", "1/2"),
+    (r"\sqrt{16}", "√16"),
+    ("обычный текст без формул", "обычный текст без формул"),
+    ("$$x^2 + y^2$$", "x² + y²"),
+])
+def test_scrub_latex_exact_replacements(source, expected):
+    assert lumen_formatting._scrub_latex(source) == expected
 
 
 def test_scrub_latex_converts_common_symbols():
@@ -191,10 +177,6 @@ def test_scrub_latex_converts_common_symbols():
     assert "×" in result and "±" in result and "≤" in result and "≥" in result and "∞" in result
 
 
-def test_scrub_latex_noop_when_no_backslash_or_dollar():
-    assert lumen_formatting._scrub_latex("обычный текст без формул") == "обычный текст без формул"
-
-
 def test_scrub_latex_does_not_confuse_currency_with_math_delimiters():
     # РЕГРЕССИЯ, найденная при code-review (25 июля 2026): первая версия скрубера
     # обрабатывала и одиночный "$...$" как инлайн-LaTeX. Если в одном сообщении
@@ -204,17 +186,13 @@ def test_scrub_latex_does_not_confuse_currency_with_math_delimiters():
     # ("цена 100, а формула x²$ рядом"). Одиночный "$" теперь не обрабатывается
     # вообще — только "$$...$$". Сами доллары остаются нетронутыми в обоих случаях;
     # "x^2" внутри всё равно аккуратно превращается в "x²" — это отдельная, не
-    # завязанная на "$"-разделители замена (см. следующий тест), она безвредна и
-    # здесь, и вне контекста "$".
+    # завязанная на "$"-разделители замена (см. test_scrub_latex_exact_replacements),
+    # она безвредна и здесь, и вне контекста "$".
     assert lumen_formatting._scrub_latex("цена $100, а формула $x^2$ рядом") == "цена $100, а формула $x²$ рядом"
     assert lumen_formatting._scrub_latex("первый вариант — $50, второй — $100") == "первый вариант — $50, второй — $100"
     assert lumen_formatting._scrub_latex("стоимость: $100. Итого: $200.") == "стоимость: $100. Итого: $200."
 
 
-def test_scrub_latex_still_converts_double_dollar_display_math():
-    assert lumen_formatting._scrub_latex("$$x^2 + y^2$$") == "x² + y²"
-
-
 def test_scrub_latex_order_sensitive_replacements_dont_corrupt_each_other():
     # РЕГРЕССИЯ НА БУДУЩЕЕ: _LATEX_SYMBOL_MAP — это plain str.replace() в порядке
     # вставки словаря, а не regex. "\le" — подстрока "\leq", "\in" — подстрока
@@ -244,13 +222,13 @@ def test_scrub_latex_protected_inside_code_blocks_via_full_pipeline():
 # `code`/таблицы, но раньше НЕ трогал обычные markdown-списки — они уходили в
 # Telegram буквально с "-"/"*" в начале строки.
 
-def test_normalize_bullet_markers_converts_dash_and_asterisk():
-    assert lumen_formatting._normalize_bullet_markers("- Пункт один\n- Пункт два") == "• Пункт один\n• Пункт два"
-    assert lumen_formatting._normalize_bullet_markers("* Пункт один\n* Пункт два") == "• Пункт один\n• Пункт два"
-
-
-def test_normalize_bullet_markers_preserves_indentation():
-    assert lumen_formatting._normalize_bullet_markers("  - вложенный пункт") == "  • вложенный пункт"
+@pytest.mark.parametrize(("source", "expected"), [
+    ("- Пункт один\n- Пункт два", "• Пункт один\n• Пункт два"),
+    ("* Пункт один\n* Пункт два", "• Пункт один\n• Пункт два"),
+    ("  - вложенный пункт", "  • вложенный пункт"),
+])
+def test_normalize_bullet_markers(source, expected):
+    assert lumen_formatting._normalize_bullet_markers(source) == expected
 
 
 def test_normalize_bullet_markers_does_not_touch_bold_at_line_start():
@@ -283,45 +261,37 @@ def test_split_inline_bullets_ignores_short_prose():
     assert lumen_formatting._split_inline_bullets("На выбор чай • кофе.") == "На выбор чай • кофе."
 
 
-def test_split_inline_bullets_splits_three_item_prod_answer():
-    # Прод 26.09.2026: ровно 3 пункта (2 разделителя) — самый частый живой случай,
-    # со старым порогом 3 не ловился вообще (ответы про небо и мелодрамы).
-    text = (
+@pytest.mark.parametrize(("text", "n_lines", "intro"), [
+    # Прод 26.09.2026: ровно 3 пункта (2 разделителя) — самый частый живой случай.
+    (
         "• Рассеяние Рэлея: мелкие частицы в атмосфере рассеивают коротковолновый свет. "
         "• Солнечный спектр: солнце излучает больше синего света днём и ночью. "
-        "• Отсутствие поглощения: газы атмосферы почти не поглощают синий свет."
-    )
-    assert len(text) >= 200
-    lines = lumen_formatting._split_inline_bullets(text).split("\n")
-    assert len(lines) == 3
-    assert all(line.startswith("• ") for line in lines)
-
-
-def test_split_inline_bullets_splits_glued_without_spaces():
-    # Прод 05.10.2026: скриншот — модель склеила список способностей вообще без
-    # пробелов вокруг "•", старая сетка на " • " его не видела.
-    text = (
+        "• Отсутствие поглощения: газы атмосферы почти не поглощают синий свет.",
+        3, None,
+    ),
+    # Прод 05.10.2026: склейка вообще без пробелов вокруг "•".
+    (
         "• Отвечать на вопросы, вести беседу.• Выполнять веб-поиск и использовать полученные данные. "
-        "•Читать открытые веб-страницы и анализировать их содержание.• Анализировать присланные фото, видео и документы."
-    )
-    assert len(text) >= 200
-    lines = lumen_formatting._split_inline_bullets(text).split("\n")
-    assert len(lines) == 4
-    assert all(line.startswith("• ") for line in lines)
-    assert "" not in lines
-
-
-def test_split_inline_bullets_splits_middot_variant():
+        "•Читать открытые веб-страницы и анализировать их содержание.• Анализировать присланные фото, видео и документы.",
+        4, None,
+    ),
     # Та же склейка маркером "·": другой символ, та же каша для читателя.
-    text = (
+    (
         "Итоги такие: первый пункт с подробностями для длины строки и смыслом · второй пункт с подробностями "
-        "для длины строки и смыслом · третий пункт с подробностями для длины строки и смыслом · четвёртый пункт."
-    )
+        "для длины строки и смыслом · третий пункт с подробностями для длины строки и смыслом · четвёртый пункт.",
+        4, "Итоги такие: ",
+    ),
+])
+def test_split_inline_bullets_splits_prod_answers(text, n_lines, intro):
     assert len(text) >= 200
     lines = lumen_formatting._split_inline_bullets(text).split("\n")
-    assert len(lines) == 4
-    assert lines[0].startswith("Итоги такие: ")
-    assert all(line.startswith("• ") for line in lines[1:])
+    assert len(lines) == n_lines
+    assert "" not in lines
+    if intro is None:
+        assert all(line.startswith("• ") for line in lines)
+    else:
+        assert lines[0].startswith(intro)
+        assert all(line.startswith("• ") for line in lines[1:])
 
 
 def test_md_to_html_splits_inline_bullets_end_to_end():
@@ -331,23 +301,27 @@ def test_md_to_html_splits_inline_bullets_end_to_end():
     assert result.count("\n• ") == 3
 
 
-def test_split_inline_numbered_splits_glued_sky_answer():
+@pytest.mark.parametrize(("text", "intro"), [
     # Прод 25.09.2026: модель написала "1. ... 2. ... 3. ..." одним абзацем.
-    text = (
+    (
         "1. Рэлеевское рассеяние — молекулы воздуха рассеивают солнечный свет. "
         "2. Зависимость от длины волны — короткие волны рассеиваются сильнее. "
-        "3. Восприятие глаза — глаз чувствительнее к синему цвету неба."
-    )
-    lines = lumen_formatting._split_inline_numbered(text).split("\n")
-    assert len(lines) == 3
-    assert lines[0].startswith("1. ") and lines[1].startswith("2. ") and lines[2].startswith("3. ")
-
-
-def test_split_inline_numbered_keeps_intro_on_own_line():
-    text = "Причины такие: 1. Первая причина с длинным пояснением текста. 2. Вторая причина с длинным пояснением текста. 3. Третья причина с длинным пояснением текста."
+        "3. Восприятие глаза — глаз чувствительнее к синему цвету неба.",
+        None,
+    ),
+    (
+        "Причины такие: 1. Первая причина с длинным пояснением текста. 2. Вторая причина с длинным пояснением текста. 3. Третья причина с длинным пояснением текста.",
+        "Причины такие:",
+    ),
+])
+def test_split_inline_numbered_splits_glued_lists(text, intro):
     lines = lumen_formatting._split_inline_numbered(text).split("\n")
-    assert lines[0] == "Причины такие:"
-    assert [l[:2] for l in lines[1:]] == ["1.", "2.", "3."]
+    if intro is None:
+        assert len(lines) == 3
+        assert lines[0].startswith("1. ") and lines[1].startswith("2. ") and lines[2].startswith("3. ")
+    else:
+        assert lines[0] == intro
+        assert [line[:2] for line in lines[1:]] == ["1.", "2.", "3."]
 
 
 def test_split_inline_numbered_ignores_prose_and_versions():
@@ -421,15 +395,6 @@ def test_render_paths_differ_only_for_headings():
     assert lumen_formatting._md_to_rich_html("## Title") == "<h3>Title</h3>"
 
 
-def test_streaming_history_uses_summarizing_trim():
-    # Стриминговый путь резал историю голым del, из-за чего саммаризация старого
-    # работала только в нестриминговых ветках (аудит 26.09.2026).
-    src = inspect.getsource(lumen_streaming._run_streaming_reply)
-    code_lines = [ln for ln in src.splitlines() if not ln.strip().startswith("#")]
-    assert any("_trim_history" in ln for ln in code_lines)
-    assert not any("hist[:-" in ln for ln in code_lines), "в стриминге остался молчаливый срез истории"
-
-
 def test_md_to_rich_html_splits_three_bullets_prod_movies():
     # Прод 26.09.2026: ответ про мелодрамы — 3 пункта склеились, rich-путь молчал.
     text = (
@@ -455,13 +420,13 @@ def test_md_to_html_full_pipeline_converts_bullet_list_with_bold():
 # модели OpenRouter) регулярно их всё равно пишут — раньше "###" уходило в
 # Telegram буквально, без единой защитной сетки (в отличие от таблиц/списков).
 
-def test_normalize_headers_converts_h3_to_bold():
-    assert lumen_formatting._normalize_headers("### Как она выводится?") == "**Как она выводится?**"
-
-
-def test_normalize_headers_converts_h1_and_h2():
-    assert lumen_formatting._normalize_headers("# Заголовок") == "**Заголовок**"
-    assert lumen_formatting._normalize_headers("## Подзаголовок") == "**Подзаголовок**"
+@pytest.mark.parametrize(("source", "expected"), [
+    ("### Как она выводится?", "**Как она выводится?**"),
+    ("# Заголовок", "**Заголовок**"),
+    ("## Подзаголовок", "**Подзаголовок**"),
+])
+def test_normalize_headers_converts_atx_to_bold(source, expected):
+    assert lumen_formatting._normalize_headers(source) == expected
 
 
 def test_normalize_headers_does_not_touch_hash_mid_line():
@@ -504,20 +469,16 @@ def test_md_to_html_header_hash_inside_code_block_untouched():
 
 # ─────────────────── spoiler-тег: защитная сетка (тот же принцип, что <u>) ───────────────────
 
-def test_md_to_html_strips_literal_spoiler_tag():
-    assert lumen_formatting._md_to_html("<tg-spoiler>секрет</tg-spoiler>") == "секрет"
-
-
-def test_md_to_html_strips_literal_span_spoiler_tag():
-    assert lumen_formatting._md_to_html('<span class="tg-spoiler">секрет</span>') == "секрет"
+@pytest.mark.parametrize(("source", "expected"), [
+    ("<tg-spoiler>секрет</tg-spoiler>", "секрет"),
+    ('<span class="tg-spoiler">секрет</span>', "секрет"),
+])
+def test_md_to_html_strips_literal_spoiler_tags(source, expected):
+    assert lumen_formatting._md_to_html(source) == expected
 
 
 # ─────────────────── подсветка синтакси��а: язык из ```fence сохраняется ───────────────────
-
-def test_md_to_html_code_block_preserves_language_for_syntax_highlighting():
-    result = lumen_formatting._md_to_html("```python\nprint(1)\n```")
-    assert result == '<pre><code class="language-python">print(1)</code></pre>'
-
+# (сам кейс с языком покрыт test_md_to_html_code_block выше)
 
 def test_md_to_html_code_block_without_language_unchanged():
     assert lumen_formatting._md_to_html("```\nprint(1)\n```") == "<pre>print(1)</pre>"
@@ -525,13 +486,12 @@ def test_md_to_html_code_block_without_language_unchanged():
 
 # ─────────────────── markdown-цитаты "> " → <blockquote> ───────────────────
 
-def test_md_to_html_converts_single_line_blockquote():
-    assert lumen_formatting._md_to_html("> цитата") == "<blockquote>цитата</blockquote>"
-
-
-def test_md_to_html_converts_multiline_blockquote_as_one_block():
-    result = lumen_formatting._md_to_html("> первая строка\n> вторая строка")
-    assert result == "<blockquote>первая строка\nвторая строка</blockquote>"
+@pytest.mark.parametrize(("source", "expected"), [
+    ("> цитата", "<blockquote>цитата</blockquote>"),
+    ("> первая строка\n> вторая строка", "<blockquote>первая строка\nвторая строка</blockquote>"),
+])
+def test_md_to_html_converts_blockquotes(source, expected):
+    assert lumen_formatting._md_to_html(source) == expected
 
 
 def test_md_to_html_blockquote_markdown_inside_still_converts():
@@ -603,16 +563,29 @@ def test_rich_non_table_pipes_left_alone():
     assert lumen_formatting._md_to_rich_html("a | b") == "a | b"
 
 
-def test_rich_headings_become_h_tags():
-    assert lumen_formatting._md_to_rich_html("## Заголовок") == "<h3>Заголовок</h3>"
-    assert lumen_formatting._md_to_rich_html("### Подзаголовок") == "<h4>Подзаголовок</h4>"
-
-
-def test_rich_math_preserved_as_tg_math_tags():
+@pytest.mark.parametrize(("source", "expected"), [
+    ("## Заголовок", "<h3>Заголовок</h3>"),
+    ("### Подзаголовок", "<h4>Подзаголовок</h4>"),
+    # Тот же допуск, что у легаси-нормализации: ведущие пробелы и 1–6 решёток.
+    ("   ## Заголовок", "<h3>Заголовок</h3>"),
+    ("# Топ", "<h2>Топ</h2>"),
+    ("#### Глубокий", "<h4>Глубокий</h4>"),
+])
+def test_rich_headings_become_h_tags(source, expected):
+    assert lumen_formatting._md_to_rich_html(source) == expected
+
+
+@pytest.mark.parametrize(("source", "expected"), [
+    ("корень $x^2$ тут", "корень <tg-math>x^2</tg-math> тут"),
+    ("формула $$E=mc^2$$ конец", "формула <tg-math-block>E=mc^2</tg-math-block> конец"),
+    # Скобочные формы LaTeX (реальный кейс nemotron) извлекаются раньше $.
+    ("смотри \\[S = \\pi r^{2}\\] конец", "смотри <tg-math-block>S = \\pi r^{2}</tg-math-block> конец"),
+    ("значение \\(x\\) тут", "значение <tg-math>x</tg-math> тут"),
+])
+def test_rich_math_preserved_as_tg_math_tags(source, expected):
     # В отличие от _md_to_html (юникод-замена), рич-путь отдаёт LaTeX сырым —
     # рендерит сервер Telegram.
-    assert lumen_formatting._md_to_rich_html("корень $x^2$ тут") == "корень <tg-math>x^2</tg-math> тут"
-    assert lumen_formatting._md_to_rich_html("формула $$E=mc^2$$ конец") == "формула <tg-math-block>E=mc^2</tg-math-block> конец"
+    assert lumen_formatting._md_to_rich_html(source) == expected
 
 
 def test_rich_keeps_bold_links_code_quotes_and_escape():
@@ -628,20 +601,6 @@ def test_rich_math_inside_code_stays_code():
     assert lumen_formatting._md_to_rich_html("`$x$`") == "<code>$x$</code>"
 
 
-def test_rich_bracket_math_forms():
-    # Скобочные формы LaTeX (реальный кейс nemotron): \[...\] — блочная,
-    # \(...\) — инлайн. Извлекаются раньше $ во избежание конфликтов.
-    assert lumen_formatting._md_to_rich_html("смотри \\[S = \\pi r^{2}\\] конец") == "смотри <tg-math-block>S = \\pi r^{2}</tg-math-block> конец"
-    assert lumen_formatting._md_to_rich_html("значение \\(x\\) тут") == "значение <tg-math>x</tg-math> тут"
-
-
-def test_rich_headings_tolerate_indent_and_deep_levels():
-    # Тот же допуск, что у легаси-нормализации: ведущие пробелы и 1–6 решёток.
-    assert lumen_formatting._md_to_rich_html("   ## Заголовок") == "<h3>Заголовок</h3>"
-    assert lumen_formatting._md_to_rich_html("# Топ") == "<h2>Топ</h2>"
-    assert lumen_formatting._md_to_rich_html("#### Глубокий") == "<h4>Глубокий</h4>"
-
-
 def test_br_tag_becomes_line_break_in_both_paths():
     # Прод-кейс 17.09.2026: модель пишет "<br>" внутри ячеек таблиц — без
     # обработки долетает до escape и светится буквально ("...сгор.<br>Pro Max").

tests/test_lumen_images.py

@@ -13,50 +13,33 @@ lumen_images.py не зависит от Telegram/рантайм-состоян
 import asyncio
 
 import lumen_images
+import pytest
 
 
 # ─────────────────────────── _pick_image_model ───────────────────────────
 
-def test_pick_image_model_anime():
-    assert lumen_images._pick_image_model("нарисуй девушку в стиле аниме") == "flux-anime"
-    assert lumen_images._pick_image_model("draw a chibi character") == "flux-anime"
-    assert lumen_images._pick_image_model("manga style portrait") == "flux-anime"
 
-
-def test_pick_image_model_fantasy():
-    assert lumen_images._pick_image_model("нарисуй дракона в фэнтезийном замке") == "dreamshaper"
-    assert lumen_images._pick_image_model("concept art of an elf wizard") == "dreamshaper"
-    assert lumen_images._pick_image_model("рыцарь на фоне волшебного леса") == "dreamshaper"
-
-
-def test_pick_image_model_realism():
-    assert lumen_images._pick_image_model("сделай фотореалистичный портрет кота") == "flux-realism"
-    assert lumen_images._pick_image_model("realistic photo of a mountain") == "flux-realism"
-    assert lumen_images._pick_image_model("нарисуй кота как на фото") == "flux-realism"
-
-
-def test_pick_image_model_quick_draft():
-    assert lumen_images._pick_image_model("быстрый набросок логотипа") == "turbo"
-    assert lumen_images._pick_image_model("quick sketch of a car") == "turbo"
-
-
-def test_pick_image_model_falls_back_to_default_for_generic_prompt():
-    assert lumen_images._pick_image_model("космическая станция на орбите Земли") == lumen_images.DEFAULT_POLLINATIONS_IMAGE_MODEL
-    assert lumen_images._pick_image_model("кот на подоконнике") == lumen_images.DEFAULT_POLLINATIONS_IMAGE_MODEL
-
-
-def test_pick_image_model_empty_prompt_returns_default():
-    assert lumen_images._pick_image_model("") == lumen_images.DEFAULT_POLLINATIONS_IMAGE_MODEL
-
-
-def test_pick_image_model_style_keyword_wins_over_quick_keyword():
-    # Стилевой сигнал важнее просьбы "побыстрее", если оба есть в одном промпте —
-    # аниме проверяется раньше черновика/скетча (см. докстринг _pick_image_model).
-    assert lumen_images._pick_image_model("быстро нарисуй аниме-девушку") == "flux-anime"
-
-
-def test_pick_image_model_case_insensitive():
-    assert lumen_images._pick_image_model("АНИМЕ ДЕВУШКА") == "flux-anime"
+@pytest.mark.parametrize(("prompt", "expected"), [
+    ("нарисуй девушку в стиле аниме", "flux-anime"),
+    ("draw a chibi character", "flux-anime"),
+    ("manga style portrait", "flux-anime"),
+    ("нарисуй дракона в фэнтезийном замке", "dreamshaper"),
+    ("concept art of an elf wizard", "dreamshaper"),
+    ("рыцарь на фоне волшебного леса", "dreamshaper"),
+    ("сделай фотореалистичный портрет кота", "flux-realism"),
+    ("realistic photo of a mountain", "flux-realism"),
+    ("нарисуй кота как на фото", "flux-realism"),
+    ("быстрый набросок логотипа", "turbo"),
+    ("quick sketch of a car", "turbo"),
+    ("космическая станция на орбите Земли", lumen_images.DEFAULT_POLLINATIONS_IMAGE_MODEL),
+    ("кот на подоконнике", lumen_images.DEFAULT_POLLINATIONS_IMAGE_MODEL),
+    ("", lumen_images.DEFAULT_POLLINATIONS_IMAGE_MODEL),
+    # Стилевой сигнал важнее просьбы "побыстрее": аниме проверяется раньше черновика.
+    ("быстро нарисуй аниме-девушку", "flux-anime"),
+    ("АНИМЕ ДЕВУШКА", "flux-anime"),
+])
+def test_pick_image_model(prompt, expected):
+    assert lumen_images._pick_image_model(prompt) == expected
 
 
 def test_pick_image_model_result_always_a_known_model():