Split core and TUI crates

crates/tele-tui/src/test_support/app_builder.rs

@@ -0,0 +1,288 @@
+// Test App builder
+
+use super::FakeTdClient;
+use crate::app::{App, AppScreen, ChatState, InputMode};
+use crate::config::Config;
+use crate::tdlib::AuthState;
+use crate::tdlib::{ChatInfo, MessageInfo};
+use crate::types::{ChatId, MessageId};
+use ratatui::widgets::ListState;
+use std::collections::HashMap;
+
+/// Builder для создания тестового App с FakeTdClient\n///\n/// Использует trait-based DI для подмены TdClient на FakeTdClient в тестах.
+#[allow(dead_code)]
+pub struct TestAppBuilder {
+    config: Config,
+    screen: AppScreen,
+    chats: Vec<ChatInfo>,
+    selected_chat_id: Option<i64>,
+    message_input: String,
+    is_searching: bool,
+    search_query: String,
+    chat_state: Option<ChatState>,
+    input_mode: Option<InputMode>,
+    messages: HashMap<i64, Vec<MessageInfo>>,
+    status_message: Option<String>,
+    auth_state: Option<AuthState>,
+    phone_input: Option<String>,
+    code_input: Option<String>,
+    password_input: Option<String>,
+}
+
+impl Default for TestAppBuilder {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+#[allow(dead_code)]
+impl TestAppBuilder {
+    pub fn new() -> Self {
+        Self {
+            config: Config::default(),
+            screen: AppScreen::Main,
+            chats: vec![],
+            selected_chat_id: None,
+            message_input: String::new(),
+            is_searching: false,
+            search_query: String::new(),
+            chat_state: None,
+            input_mode: None,
+            messages: HashMap::new(),
+            status_message: None,
+            auth_state: None,
+            phone_input: None,
+            code_input: None,
+            password_input: None,
+        }
+    }
+
+    /// Установить экран
+    pub fn screen(mut self, screen: AppScreen) -> Self {
+        self.screen = screen;
+        self
+    }
+
+    /// Установить конфиг
+    pub fn config(mut self, config: Config) -> Self {
+        self.config = config;
+        self
+    }
+
+    /// Добавить чат
+    pub fn with_chat(mut self, chat: ChatInfo) -> Self {
+        self.chats.push(chat);
+        self
+    }
+
+    /// Добавить несколько чатов
+    pub fn with_chats(mut self, chats: Vec<ChatInfo>) -> Self {
+        self.chats.extend(chats);
+        self
+    }
+
+    /// Выбрать чат
+    pub fn selected_chat(mut self, chat_id: i64) -> Self {
+        self.selected_chat_id = Some(chat_id);
+        self
+    }
+
+    /// Установить текст в инпуте
+    pub fn message_input(mut self, text: &str) -> Self {
+        self.message_input = text.to_string();
+        self
+    }
+
+    /// Режим поиска
+    pub fn searching(mut self, query: &str) -> Self {
+        self.is_searching = true;
+        self.search_query = query.to_string();
+        self
+    }
+
+    /// Режим редактирования сообщения
+    pub fn editing_message(mut self, message_id: i64, selected_index: usize) -> Self {
+        self.chat_state = Some(ChatState::Editing {
+            message_id: MessageId::new(message_id),
+            selected_index,
+        });
+        self
+    }
+
+    /// Режим ответа на сообщение
+    pub fn replying_to(mut self, message_id: i64) -> Self {
+        self.chat_state = Some(ChatState::Reply { message_id: MessageId::new(message_id) });
+        self
+    }
+
+    /// Режим выбора реакции
+    pub fn reaction_picker(mut self, message_id: i64, available_reactions: Vec<String>) -> Self {
+        self.chat_state = Some(ChatState::ReactionPicker {
+            message_id: MessageId::new(message_id),
+            available_reactions,
+            selected_index: 0,
+        });
+        self
+    }
+
+    /// Режим профиля
+    pub fn profile_mode(mut self, info: crate::tdlib::ProfileInfo) -> Self {
+        self.chat_state = Some(ChatState::Profile {
+            info,
+            selected_action: 0,
+            leave_group_confirmation_step: 0,
+        });
+        self
+    }
+
+    /// Подтверждение удаления
+    pub fn delete_confirmation(mut self, message_id: i64) -> Self {
+        self.chat_state =
+            Some(ChatState::DeleteConfirmation { message_id: MessageId::new(message_id) });
+        self
+    }
+
+    /// Добавить сообщение для чата
+    pub fn with_message(mut self, chat_id: i64, message: MessageInfo) -> Self {
+        self.messages.entry(chat_id).or_default().push(message);
+        self
+    }
+
+    /// Добавить несколько сообщений для чата
+    pub fn with_messages(mut self, chat_id: i64, messages: Vec<MessageInfo>) -> Self {
+        self.messages.entry(chat_id).or_default().extend(messages);
+        self
+    }
+
+    /// Установить выбранное сообщение (режим selection)
+    pub fn selecting_message(mut self, selected_index: usize) -> Self {
+        self.chat_state = Some(ChatState::MessageSelection { selected_index });
+        self
+    }
+
+    /// Режим поиска по сообщениям в чате
+    pub fn message_search(mut self, query: &str) -> Self {
+        self.chat_state = Some(ChatState::SearchInChat {
+            query: query.to_string(),
+            results: Vec::new(),
+            selected_index: 0,
+        });
+        self
+    }
+
+    /// Установить Insert mode
+    pub fn insert_mode(mut self) -> Self {
+        self.input_mode = Some(InputMode::Insert);
+        self
+    }
+
+    /// Режим пересылки сообщения
+    pub fn forward_mode(mut self, message_id: i64) -> Self {
+        self.chat_state = Some(ChatState::Forward { message_id: MessageId::new(message_id) });
+        self
+    }
+
+    /// Установить статус сообщение (для loading screen)
+    pub fn status_message(mut self, message: &str) -> Self {
+        self.status_message = Some(message.to_string());
+        self
+    }
+
+    /// Установить auth state
+    pub fn auth_state(mut self, state: AuthState) -> Self {
+        self.auth_state = Some(state);
+        self
+    }
+
+    /// Установить phone input
+    pub fn phone_input(mut self, phone: &str) -> Self {
+        self.phone_input = Some(phone.to_string());
+        self
+    }
+
+    /// Установить code input
+    pub fn code_input(mut self, code: &str) -> Self {
+        self.code_input = Some(code.to_string());
+        self
+    }
+
+    /// Установить password input
+    pub fn password_input(mut self, password: &str) -> Self {
+        self.password_input = Some(password.to_string());
+        self
+    }
+
+    /// Построить App с FakeTdClient
+    ///
+    /// Создаёт App с FakeTdClient, подходит для любых тестов включая
+    /// интеграционные тесты логики.
+    pub fn build(self) -> App<FakeTdClient> {
+        // Создаём FakeTdClient с чатами и сообщениями
+        let mut fake_client = FakeTdClient::new();
+
+        // Добавляем чаты
+        for chat in &self.chats {
+            fake_client = fake_client.with_chat(chat.clone());
+        }
+
+        // Добавляем сообщения
+        for (chat_id, messages) in self.messages {
+            fake_client = fake_client.with_messages(chat_id, messages);
+        }
+
+        // Устанавливаем текущий чат если нужно
+        if let Some(chat_id) = self.selected_chat_id {
+            *fake_client.current_chat_id.lock().unwrap() = Some(chat_id);
+        }
+
+        // Устанавливаем auth state если нужно
+        if let Some(auth_state) = self.auth_state {
+            fake_client = fake_client.with_auth_state(auth_state);
+        }
+
+        // Создаём App с FakeTdClient
+        let mut app = App::with_client(self.config, fake_client);
+
+        app.screen = self.screen;
+        app.chats = self.chats;
+        app.selected_chat_id = self.selected_chat_id.map(ChatId::new);
+        app.message_input = self.message_input;
+        app.is_searching = self.is_searching;
+        app.search_query = self.search_query;
+
+        // Применяем chat_state если он установлен
+        if let Some(chat_state) = self.chat_state {
+            app.chat_state = chat_state;
+        }
+
+        // Применяем input_mode если он установлен
+        if let Some(input_mode) = self.input_mode {
+            app.input_mode = input_mode;
+        }
+
+        // Применяем status_message
+        if let Some(status) = self.status_message {
+            app.status_message = Some(status);
+        }
+
+        // Применяем auth inputs
+        if let Some(phone) = self.phone_input {
+            app.set_phone_input(phone);
+        }
+        if let Some(code) = self.code_input {
+            app.set_code_input(code);
+        }
+        if let Some(password) = self.password_input {
+            app.set_password_input(password);
+        }
+
+        // Выбираем первый чат если есть
+        if !app.chats.is_empty() {
+            let mut list_state = ListState::default();
+            list_state.select(Some(0));
+            app.chat_list_state = list_state;
+        }
+
+        app
+    }
+}

crates/tele-tui/src/test_support/mod.rs

@@ -0,0 +1,6 @@
+//! Test-only support for deterministic UI fixtures and integration tests.
+
+pub mod app_builder;
+pub mod snapshot_utils;
+
+pub use tele_core::test_support::{fake_tdclient, test_data, FakeTdClient};

crates/tele-tui/src/test_support/snapshot_utils.rs

@@ -0,0 +1,144 @@
+// Snapshot testing utilities
+
+use ratatui::backend::TestBackend;
+use ratatui::buffer::Buffer;
+use ratatui::style::{Color, Modifier};
+use ratatui::Terminal;
+
+/// Конвертирует Buffer в читаемую строку для snapshot тестов
+pub fn buffer_to_string(buffer: &Buffer) -> String {
+    let area = buffer.area();
+    let mut result = String::new();
+
+    for y in 0..area.height {
+        let mut line = String::new();
+        for x in 0..area.width {
+            line.push_str(buffer[(x, y)].symbol());
+        }
+        // Убираем trailing spaces в конце строки
+        result.push_str(line.trim_end());
+        if y < area.height - 1 {
+            result.push('\n');
+        }
+    }
+
+    result
+}
+
+/// Serializes only cells with non-default style, grouped by row and style.
+pub fn buffer_to_style_snapshot(buffer: &Buffer) -> String {
+    let area = buffer.area();
+    let mut rows = Vec::new();
+
+    for y in 0..area.height {
+        let mut segments = Vec::new();
+        let mut x = 0;
+
+        while x < area.width {
+            let cell = &buffer[(x, y)];
+            if is_default_style(cell) {
+                x += 1;
+                continue;
+            }
+
+            let start = x;
+            let fg = cell.fg;
+            let bg = cell.bg;
+            let modifier = cell.modifier;
+            let mut text = String::new();
+
+            while x < area.width {
+                let next = &buffer[(x, y)];
+                if is_default_style(next)
+                    || next.fg != fg
+                    || next.bg != bg
+                    || next.modifier != modifier
+                {
+                    break;
+                }
+                text.push_str(next.symbol());
+                x += 1;
+            }
+
+            segments.push(format!(
+                "{}..{} {:?}/{:?}/{:?}: {:?}",
+                start,
+                x.saturating_sub(1),
+                fg,
+                bg,
+                modifier,
+                text.trim_end()
+            ));
+        }
+
+        if !segments.is_empty() {
+            rows.push(format!("y={}: {}", y, segments.join(" | ")));
+        }
+    }
+
+    rows.join("\n")
+}
+
+fn is_default_style(cell: &ratatui::buffer::Cell) -> bool {
+    cell.fg == Color::Reset && cell.bg == Color::Reset && cell.modifier == Modifier::empty()
+}
+
+/// Создаёт TestBackend с заданным размером и рендерит UI
+pub fn render_to_buffer<F>(width: u16, height: u16, render_fn: F) -> Buffer
+where
+    F: FnOnce(&mut ratatui::Frame),
+{
+    let backend = TestBackend::new(width, height);
+    let mut terminal = Terminal::new(backend).unwrap();
+
+    terminal.draw(render_fn).unwrap();
+
+    terminal.backend().buffer().clone()
+}
+
+/// Макрос для упрощения snapshot тестов
+#[macro_export]
+macro_rules! assert_ui_snapshot {
+    ($name:expr, $width:expr, $height:expr, $render_fn:expr) => {{
+        use $crate::test_support::snapshot_utils::{buffer_to_string, render_to_buffer};
+        let buffer = render_to_buffer($width, $height, $render_fn);
+        let output = buffer_to_string(&buffer);
+        insta::assert_snapshot!($name, output);
+    }};
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use ratatui::layout::Rect;
+    use ratatui::widgets::{Block, Borders};
+
+    #[test]
+    fn test_buffer_to_string_simple() {
+        let buffer = render_to_buffer(10, 3, |f| {
+            let block = Block::default().borders(Borders::ALL).title("Hi");
+            f.render_widget(block, f.area());
+        });
+
+        let result = buffer_to_string(&buffer);
+        assert!(result.contains("Hi"));
+        assert!(result.contains("┌"));
+        assert!(result.contains("└"));
+    }
+
+    #[test]
+    fn test_buffer_to_string_removes_trailing_spaces() {
+        let buffer = render_to_buffer(20, 3, |f| {
+            let block = Block::default().title("Test");
+            f.render_widget(block, Rect::new(0, 0, 10, 3));
+        });
+
+        let result = buffer_to_string(&buffer);
+        let lines: Vec<&str> = result.lines().collect();
+
+        // Проверяем что trailing spaces убраны
+        for line in lines {
+            assert!(!line.ends_with(' ') || line.trim().is_empty());
+        }
+    }
+}