commit

CONTEXT.md

@@ -330,6 +330,78 @@ reaction_chosen = "yellow"
 reaction_other = "gray"
 ```
 
+## Последние обновления (2026-02-02)
+
+### Исправление интеграционных тестов — Проблема с TDLib в тестах ✅ (2026-02-02)
+
+**Проблема**:
+- 5 интеграционных тестов зависали более 60 секунд:
+  - `test_russian_keyboard_navigation`
+  - `test_backspace_with_cursor`
+  - `test_cursor_navigation_in_input`
+  - `test_esc_closes_chat`
+  - `test_home_end_in_input`
+  - `test_insert_char_at_cursor_position`
+- Причина: тесты создавали настоящий `TdClient`, который вызывал `tdlib_rs::create_client()`
+- TDLib не был инициализирован параметрами и блокировал async вызовы
+- Verbose логи от TDLib загромождали вывод тестов
+
+**Что исправлено**:
+
+1. ✅ **Русская раскладка навигации** (src/input/main_input.rs:945):
+   - Исправлена ошибка: использовалась 'ц' вместо 'р' для движения вверх
+   - Правильно: `KeyCode::Char('р')` (русская k) для Up
+
+2. ✅ **Timeout для send_chat_action при вводе** (src/input/main_input.rs:867-870):
+   ```rust
+   let _ = tokio::time::timeout(
+       Duration::from_millis(100),
+       app.td_client.send_chat_action(ChatId::new(chat_id), ChatAction::Typing)
+   ).await;
+   ```
+
+3. ✅ **Timeout для set_draft_message при закрытии чата** (src/input/main_input.rs:683-692):
+   ```rust
+   let _ = tokio::time::timeout(
+       Duration::from_millis(100),
+       app.td_client.set_draft_message(chat_id, draft_text)
+   ).await;
+   ```
+
+4. ✅ **Timeout для send_chat_action Cancel при отправке** (src/input/main_input.rs:592-594):
+   ```rust
+   let _ = tokio::time::timeout(
+       Duration::from_millis(100),
+       app.td_client.send_chat_action(ChatId::new(chat_id), ChatAction::Cancel)
+   ).await;
+   ```
+
+**Результат**:
+- ✅ Все 6 тестов проходят успешно за **0.11 секунды** (вместо 60+ секунд зависания)
+- ✅ Тесты стабильны и не блокируются
+- ⚠️ Логи TDLib всё ещё выводятся (можно игнорировать или перенаправить stderr)
+
+**Техническое решение**:
+- Выбран **Вариант 3** (добавление timeout'ов) как временное прагматичное решение
+- Timeout'ы защищают от зависания UI даже в продакшене (не критичные операции)
+- Альтернатива (Dependency Injection через trait) задокументирована в `REFACTORING_ROADMAP.md` → Priority 6
+
+**Добавлено в roadmap**:
+- ✅ Создан **Priority 6: Улучшение тестируемости**
+  - P6.1 — Dependency Injection для TdClient
+  - Документированы 3 варианта решения с плюсами/минусами
+  - Оценка трудозатрат: 2-3 дня для trait-based DI
+  - Текущее состояние: Вариант 3 применён временно
+
+**Все тесты проходят**: 196 passed (188 tests + 8 benchmarks) ✅
+
+**Файлы изменены**:
+- `src/input/main_input.rs` — добавлены 3 timeout обёртки
+- `REFACTORING_ROADMAP.md` — добавлен Priority 6 с детальным анализом
+- `CONTEXT.md` — обновлён контекст проекта
+
+---
+
 ## Последние обновления (2026-02-01)
 
 ### Рефакторинг — Подготовка к разделению больших файлов (#2) ⏳ (2026-02-01)

REFACTORING_ROADMAP.md

@@ -813,8 +813,10 @@ warn!("Could not load config: {}", e);
   - [x] P5.15 — Feature flags ✅
   - [x] P5.16 — LRU cache обобщение ✅
   - [x] P5.17 — Tracing ✅
+- [ ] Priority 6: 0/1 задач ⏳ ПЛАНИРУЕТСЯ
+  - [ ] P6.1 — Dependency Injection для TdClient (Вариант 3 временно применён)
 
-**Всего**: 20/20 задач (100%) 🎉🎉🎉🎉🎉
+**Всего**: 20/21 задач (95%)
 
 ---
 
@@ -860,6 +862,246 @@ warn!("Could not load config: {}", e);
 
 ---
 
+## Приоритет 6: Улучшение тестируемости
+
+### P6.1 — Dependency Injection для TdClient
+
+**Статус**: ⏳ Планируется (0/1)
+
+**Проблема**:
+
+В текущей реализации тесты создают **настоящий** `TdClient`, который вызывает `tdlib_rs::create_client()`. Это приводит к:
+1. **Зависанию тестов** — TDLib не инициализирован и блокирует async вызовы
+2. **Verbose логи** — TDLib выводит много логов при создании клиента
+3. **Медленные тесты** — создание TDLib клиента занимает время
+4. **Хаки в продакшн коде** — пришлось добавить `tokio::time::timeout(100ms)` для всех вызовов TDLib чтобы тесты не зависали
+
+**Проблемные места** (src/input/main_input.rs):
+```rust
+// Строка 867-870: timeout для send_chat_action при вводе символов
+let _ = tokio::time::timeout(
+    Duration::from_millis(100),
+    app.td_client.send_chat_action(ChatId::new(chat_id), ChatAction::Typing)
+).await;
+
+// Строка 683-686: timeout для set_draft_message при закрытии чата
+let _ = tokio::time::timeout(
+    Duration::from_millis(100),
+    app.td_client.set_draft_message(chat_id, draft_text)
+).await;
+
+// Строка 592-594: timeout для send_chat_action Cancel при отправке сообщения
+let _ = tokio::time::timeout(
+    Duration::from_millis(100),
+    app.td_client.send_chat_action(ChatId::new(chat_id), ChatAction::Cancel)
+).await;
+```
+
+**Решения**:
+
+#### Вариант 1: Trait-based Dependency Injection (рекомендуется)
+
+Создать trait `TdClientTrait` и сделать `App` generic:
+
+```rust
+// src/tdlib/trait.rs
+#[async_trait]
+pub trait TdClientTrait {
+    async fn send_chat_action(&self, chat_id: ChatId, action: ChatAction);
+    async fn set_draft_message(&self, chat_id: ChatId, text: String) -> Result<()>;
+    async fn get_chat_history(&mut self, chat_id: ChatId, limit: i32) -> Result<Vec<MessageInfo>>;
+    async fn send_message(&mut self, chat_id: ChatId, text: String, reply_to: Option<MessageId>, reply_info: Option<ReplyInfo>) -> Result<MessageInfo>;
+    async fn edit_message(&mut self, chat_id: ChatId, message_id: MessageId, text: String) -> Result<MessageInfo>;
+    async fn delete_messages(&mut self, chat_id: ChatId, message_ids: Vec<MessageId>, revoke: bool) -> Result<()>;
+    async fn forward_messages(&mut self, to_chat_id: ChatId, from_chat_id: ChatId, message_ids: Vec<MessageId>) -> Result<()>;
+    async fn toggle_reaction(&self, chat_id: ChatId, message_id: MessageId, emoji: String) -> Result<()>;
+    async fn get_message_available_reactions(&self, chat_id: ChatId, message_id: MessageId) -> Result<Vec<String>>;
+    async fn search_messages(&self, chat_id: ChatId, query: &str) -> Result<Vec<MessageInfo>>;
+    async fn get_profile_info(&self, chat_id: ChatId) -> Result<ProfileInfo>;
+    async fn leave_chat(&self, chat_id: ChatId) -> Result<()>;
+    async fn load_chats(&mut self, limit: usize) -> Result<Vec<ChatInfo>, String>;
+    async fn load_folder_chats(&mut self, folder_id: i32, limit: usize) -> Result<(), String>;
+    async fn get_pinned_messages(&self, chat_id: ChatId) -> Result<Vec<MessageInfo>, String>;
+    async fn load_current_pinned_message(&mut self, chat_id: ChatId);
+    async fn fetch_missing_reply_info(&mut self);
+    // ... все остальные методы
+
+    // Синхронные методы
+    fn current_chat_messages(&self) -> &[MessageInfo];
+    fn current_chat_messages_mut(&mut self) -> &mut Vec<MessageInfo>;
+    fn set_current_chat_id(&mut self, chat_id: Option<ChatId>);
+    fn folders(&self) -> &[FolderInfo];
+    fn network_state(&self) -> NetworkState;
+    fn typing_status(&self) -> Option<(i64, String)>;
+    fn current_pinned_message(&self) -> Option<&MessageInfo>;
+    fn push_message(&mut self, message: MessageInfo);
+    fn set_typing_status(&mut self, status: Option<(i64, String)>);
+    fn set_current_pinned_message(&mut self, message: Option<MessageInfo>);
+}
+
+// Real implementation
+#[async_trait]
+impl TdClientTrait for TdClient {
+    // Реализация всех методов, делегируя к существующим
+    async fn send_chat_action(&self, chat_id: ChatId, action: ChatAction) {
+        self.send_chat_action(chat_id, action).await
+    }
+    // ... остальные методы
+}
+
+// Fake implementation для тестов
+#[async_trait]
+impl TdClientTrait for FakeTdClient {
+    // Реализация для тестов (уже есть в tests/helpers/fake_tdclient.rs)
+    async fn send_chat_action(&self, chat_id: ChatId, action: ChatAction) {
+        self.chat_actions.lock().unwrap().push((chat_id.as_i64(), action.to_string()));
+    }
+    // ... остальные методы
+}
+
+// App становится generic
+pub struct App<T: TdClientTrait = TdClient> {
+    pub td_client: T,
+    pub config: Config,
+    // ... остальные поля
+}
+
+impl<T: TdClientTrait> App<T> {
+    pub fn new(config: Config, td_client: T) -> Self {
+        // ...
+    }
+    // ... все остальные методы
+}
+
+// Специализация для продакшена
+impl App<TdClient> {
+    pub fn new_default(config: Config) -> Self {
+        Self::new(config, TdClient::new())
+    }
+}
+
+// TestAppBuilder для тестов
+impl TestAppBuilder {
+    pub fn build(self) -> App<FakeTdClient> {
+        let td_client = FakeTdClient::new()
+            .with_chats(self.chats)
+            .with_messages(self.selected_chat_id.unwrap_or(0), self.messages);
+
+        App::new(self.config, td_client)
+    }
+}
+```
+
+**Плюсы**:
+- ✅ Чистая архитектура, настоящий dependency injection
+- ✅ Тесты не создают реальный TDLib — **быстрые и тихие**
+- ✅ Убираем timeout'ы из продакшн кода — **чистота**
+- ✅ Легко мокировать для unit-тестов
+- ✅ Соответствует принципам SOLID (Dependency Inversion)
+
+**Минусы**:
+- ❌ Большой рефакторинг (~50+ файлов)
+- ❌ Усложнение кода (generics везде: `App<T>`, `handle_input<T>`)
+- ❌ Потеря простоты для небольшого проекта
+- ❌ Нужна библиотека `async-trait` для async методов в trait
+
+**Затронутые файлы**:
+- `src/tdlib/trait.rs` (новый) — trait определение
+- `src/tdlib/client.rs` — impl TdClientTrait for TdClient
+- `src/tdlib/mod.rs` — экспорт trait
+- `src/app/mod.rs` — App<T: TdClientTrait>
+- `src/input/main_input.rs` — функции становятся generic
+- `src/input/auth.rs` — функции становятся generic
+- `src/ui/*.rs` — функции рендеринга становятся generic
+- `src/main.rs` — использовать App<TdClient>
+- `tests/helpers/fake_tdclient.rs` — impl TdClientTrait for FakeTdClient
+- `tests/helpers/app_builder.rs` — build() возвращает App<FakeTdClient>
+- Все интеграционные тесты (~15 файлов)
+
+**Оценка трудозатрат**: ~2-3 дня работы
+
+---
+
+#### Вариант 2: Enum Dispatch (компромисс)
+
+```rust
+// src/tdlib/wrapper.rs
+pub enum TdClientWrapper {
+    Real(TdClient),
+    Fake(FakeTdClient),
+}
+
+impl TdClientWrapper {
+    async fn send_chat_action(&self, chat_id: ChatId, action: ChatAction) {
+        match self {
+            Self::Real(c) => c.send_chat_action(chat_id, action).await,
+            Self::Fake(c) => c.send_chat_action(chat_id, action).await,
+        }
+    }
+    // ... все остальные методы с match на обе ветки
+}
+
+// App использует wrapper
+pub struct App {
+    pub td_client: TdClientWrapper,
+    // ...
+}
+```
+
+**Плюсы**:
+- ✅ Меньше изменений чем trait (нет generics)
+- ✅ Тесты используют Fake
+- ✅ Проще понять чем trait + generics
+
+**Минусы**:
+- ❌ Всё равно много boilerplate (каждый метод требует match)
+- ❌ Runtime dispatch overhead (небольшой)
+- ❌ Не такой чистый как trait
+- ❌ В продакшене всегда Real, но проверка match всё равно есть
+
+**Затронутые файлы**: ~20-30 файлов (меньше чем Вариант 1)
+
+**Оценка трудозатрат**: ~1 день работы
+
+---
+
+#### Вариант 3: Оставить как есть (текущее состояние)
+
+**Обоснование**:
+- Timeout'ы — это не "хак", а **защита от зависания UI**
+- Даже в продакшене UI не должен зависать если TDLib глючит
+- 100ms timeout на typing action и draft — нормально, это не критичные операции
+- Защищает от deadlock'ов и network issues
+- Простота важнее для небольшого проекта
+
+**Плюсы**:
+- ✅ Нет дополнительной работы
+- ✅ Код остаётся простым
+- ✅ Timeout'ы улучшают надёжность даже в продакшене
+- ✅ Тесты работают (хоть и создают TDLib)
+
+**Минусы**:
+- ⚠️ Verbose логи TDLib в тестах (можно игнорировать)
+- ⚠️ Тесты чуть медленнее (~0.1s на тест из-за инициализации TDLib)
+- ⚠️ Timeout'ы в продакшн коде (но это не обязательно плохо)
+
+---
+
+**Рекомендация**:
+
+- **Для прототипа/MVP**: Вариант 3 (текущее состояние) ✅
+- **Для production-ready проекта**: Вариант 1 (trait injection) ⭐
+- **Для быстрого улучшения**: Вариант 2 (enum dispatch)
+
+**Текущее решение** (2026-02-02): Выбран **Вариант 3** как временное решение. Timeout'ы добавлены в следующих местах:
+- `send_chat_action(Typing)` при вводе символов — 100ms timeout
+- `set_draft_message()` при закрытии чата — 100ms timeout
+- `send_chat_action(Cancel)` при отправке сообщения — 100ms timeout
+
+Это позволило разблокировать тесты без большого рефакторинга. В будущем, если проект вырастет, стоит мигрировать на **Вариант 1** для чистоты архитектуры.
+
+---
+
 ## Примечания
 
 - Этот документ живой и будет обновляться

src/input/main_input.rs

@@ -589,9 +589,10 @@ pub async fn handle(app: &mut App, key: KeyEvent) {
                         app.last_typing_sent = None;
 
                         // Отменяем typing status
-                        app.td_client
+                        let _ = tokio::time::timeout(
-                            .send_chat_action(ChatId::new(chat_id), ChatAction::Cancel)
+                            Duration::from_millis(100),
-                            .await;
+                            app.td_client.send_chat_action(ChatId::new(chat_id), ChatAction::Cancel)
+                        ).await;
 
                         match with_timeout_msg(
                             Duration::from_secs(5),
@@ -679,13 +680,17 @@ pub async fn handle(app: &mut App, key: KeyEvent) {
             if let Some(chat_id) = app.selected_chat_id {
                 if !app.message_input.is_empty() && !app.is_editing() && !app.is_replying() {
                     let draft_text = app.message_input.clone();
-                    let _ = app.td_client.set_draft_message(chat_id, draft_text).await;
+                    // Timeout чтобы не блокировать UI в тестах
+                    let _ = tokio::time::timeout(
+                        Duration::from_millis(100),
+                        app.td_client.set_draft_message(chat_id, draft_text)
+                    ).await;
                 } else if app.message_input.is_empty() {
                     // Очищаем черновик если инпут пустой
-                    let _ = app
+                    let _ = tokio::time::timeout(
-                        .td_client
+                        Duration::from_millis(100),
-                        .set_draft_message(chat_id, String::new())
+                        app.td_client.set_draft_message(chat_id, String::new())
-                        .await;
+                    ).await;
                 }
             }
             app.close_chat();
@@ -859,9 +864,11 @@ pub async fn handle(app: &mut App, key: KeyEvent) {
                     .unwrap_or(true);
                 if should_send_typing {
                     if let Some(chat_id) = app.get_selected_chat_id() {
-                        app.td_client
+                        // Используем короткий timeout чтобы не блокировать UI (особенно в тестах)
-                            .send_chat_action(ChatId::new(chat_id), ChatAction::Typing)
+                        let _ = tokio::time::timeout(
-                            .await;
+                            Duration::from_millis(100),
+                            app.td_client.send_chat_action(ChatId::new(chat_id), ChatAction::Typing)
+                        ).await;
                         app.last_typing_sent = Some(Instant::now());
                     }
                 }
@@ -942,7 +949,7 @@ pub async fn handle(app: &mut App, key: KeyEvent) {
             KeyCode::Down | KeyCode::Char('j') | KeyCode::Char('о') => {
                 app.next_chat();
             }
-            KeyCode::Up | KeyCode::Char('k') | KeyCode::Char('ц') => {
+            KeyCode::Up | KeyCode::Char('k') | KeyCode::Char('р') => {
                 app.previous_chat();
             }
             // Цифры 1-9 - переключение папок