refactor: implement trait-based DI for TdClient and fix stack overflow

Implement complete trait-based dependency injection pattern for TdClient to enable testing with FakeTdClient mock. Fix critical stack overflow bugs caused by infinite recursion in trait implementations. Breaking Changes: - App is now generic: App<T: TdClientTrait = TdClient> - All UI and input handlers are generic over TdClientTrait - TdClient methods now accessed through trait interface New Files: - src/tdlib/trait.rs: TdClientTrait definition with 40+ methods - src/tdlib/client_impl.rs: TdClientTrait impl for TdClient - tests/helpers/fake_tdclient_impl.rs: TdClientTrait impl for FakeTdClient Critical Fixes: - Fix stack overflow in send_message, edit_message, delete_messages - Fix stack overflow in forward_messages, current_chat_messages - Fix stack overflow in current_pinned_message - All methods now call message_manager directly to avoid recursion Testing: - FakeTdClient supports configurable auth_state for auth screen tests - Added pinned message support in FakeTdClient - All 196+ tests passing (188 tests + 8 benchmarks) Dependencies: - Added async-trait = "0.1" Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>
2026-02-02 05:42:19 +03:00
parent ed5a4f9c72
commit 8e48d076de
38 changed files with 1053 additions and 161 deletions
--- a/tests/helpers/fake_tdclient_impl.rs
+++ b/tests/helpers/fake_tdclient_impl.rs
@@ -0,0 +1,298 @@
+//! Implementation of TdClientTrait for FakeTdClient
+
+use super::fake_tdclient::FakeTdClient;
+use async_trait::async_trait;
+use tdlib_rs::enums::{ChatAction, Update};
+use tele_tui::tdlib::{AuthState, ChatInfo, FolderInfo, MessageInfo, ProfileInfo, ReplyInfo, UserCache, UserOnlineStatus};
+use tele_tui::tdlib::TdClientTrait;
+use tele_tui::types::{ChatId, MessageId, UserId};
+
+#[async_trait]
+impl TdClientTrait for FakeTdClient {
+    // ============ Auth methods (not implemented for fake) ============
+    async fn send_phone_number(&self, _phone: String) -> Result<(), String> {
+        Ok(())
+    }
+
+    async fn send_code(&self, _code: String) -> Result<(), String> {
+        Ok(())
+    }
+
+    async fn send_password(&self, _password: String) -> Result<(), String> {
+        Ok(())
+    }
+
+    // ============ Chat methods ============
+    async fn load_chats(&mut self, limit: i32) -> Result<(), String> {
+        // FakeTdClient loads chats but returns void
+        let _ = FakeTdClient::load_chats(self, limit as usize).await?;
+        Ok(())
+    }
+
+    async fn load_folder_chats(&mut self, folder_id: i32, limit: i32) -> Result<(), String> {
+        FakeTdClient::load_folder_chats(self, folder_id, limit as usize).await
+    }
+
+    async fn leave_chat(&self, _chat_id: ChatId) -> Result<(), String> {
+        // Not implemented for fake client
+        Ok(())
+    }
+
+    async fn get_profile_info(&self, chat_id: ChatId) -> Result<ProfileInfo, String> {
+        FakeTdClient::get_profile_info(self, chat_id).await
+    }
+
+    // ============ Chat actions ============
+    async fn send_chat_action(&self, chat_id: ChatId, action: ChatAction) {
+        let action_str = format!("{:?}", action);
+        FakeTdClient::send_chat_action(self, chat_id, action_str).await;
+    }
+
+    fn clear_stale_typing_status(&mut self) -> bool {
+        // Not implemented for fake
+        false
+    }
+
+    // ============ Message methods ============
+    async fn get_chat_history(&mut self, chat_id: ChatId, limit: i32) -> Result<Vec<MessageInfo>, String> {
+        FakeTdClient::get_chat_history(self, chat_id, limit).await
+    }
+
+    async fn load_older_messages(&mut self, chat_id: ChatId, from_message_id: MessageId) -> Result<Vec<MessageInfo>, String> {
+        FakeTdClient::load_older_messages(self, chat_id, from_message_id).await
+    }
+
+    async fn get_pinned_messages(&mut self, _chat_id: ChatId) -> Result<Vec<MessageInfo>, String> {
+        // Not implemented for fake
+        Ok(vec![])
+    }
+
+    async fn load_current_pinned_message(&mut self, _chat_id: ChatId) {
+        // Not implemented for fake
+    }
+
+    async fn search_messages(&self, chat_id: ChatId, query: &str) -> Result<Vec<MessageInfo>, String> {
+        FakeTdClient::search_messages(self, chat_id, query).await
+    }
+
+    async fn send_message(
+        &mut self,
+        chat_id: ChatId,
+        text: String,
+        reply_to_message_id: Option<MessageId>,
+        reply_info: Option<ReplyInfo>,
+    ) -> Result<MessageInfo, String> {
+        FakeTdClient::send_message(self, chat_id, text, reply_to_message_id, reply_info).await
+    }
+
+    async fn edit_message(
+        &mut self,
+        chat_id: ChatId,
+        message_id: MessageId,
+        new_text: String,
+    ) -> Result<MessageInfo, String> {
+        FakeTdClient::edit_message(self, chat_id, message_id, new_text).await
+    }
+
+    async fn delete_messages(
+        &mut self,
+        chat_id: ChatId,
+        message_ids: Vec<MessageId>,
+        revoke: bool,
+    ) -> Result<(), String> {
+        FakeTdClient::delete_messages(self, chat_id, message_ids, revoke).await
+    }
+
+    async fn forward_messages(
+        &mut self,
+        to_chat_id: ChatId,
+        from_chat_id: ChatId,
+        message_ids: Vec<MessageId>,
+    ) -> Result<(), String> {
+        FakeTdClient::forward_messages(self, from_chat_id, to_chat_id, message_ids).await
+    }
+
+    async fn set_draft_message(&self, chat_id: ChatId, text: String) -> Result<(), String> {
+        FakeTdClient::set_draft_message(self, chat_id, text).await
+    }
+
+    fn push_message(&mut self, _msg: MessageInfo) {
+        // Not used in fake client
+    }
+
+    async fn fetch_missing_reply_info(&mut self) {
+        // Not used in fake client
+    }
+
+    async fn process_pending_view_messages(&mut self) {
+        // Not used in fake client
+    }
+
+    // ============ User methods ============
+    fn get_user_status_by_chat_id(&self, _chat_id: ChatId) -> Option<&UserOnlineStatus> {
+        // Not implemented for fake
+        None
+    }
+
+    async fn process_pending_user_ids(&mut self) {
+        // Not used in fake client
+    }
+
+    // ============ Reaction methods ============
+    async fn get_message_available_reactions(
+        &self,
+        chat_id: ChatId,
+        message_id: MessageId,
+    ) -> Result<Vec<String>, String> {
+        FakeTdClient::get_message_available_reactions(self, chat_id, message_id).await
+    }
+
+    async fn toggle_reaction(
+        &self,
+        chat_id: ChatId,
+        message_id: MessageId,
+        reaction: String,
+    ) -> Result<(), String> {
+        FakeTdClient::toggle_reaction(self, chat_id, message_id, reaction).await
+    }
+
+    // ============ Getters (immutable) ============
+    fn client_id(&self) -> i32 {
+        0 // Fake client ID
+    }
+
+    async fn get_me(&self) -> Result<i64, String> {
+        Ok(12345) // Fake user ID
+    }
+
+    fn auth_state(&self) -> &AuthState {
+        // Can't return reference from Arc<Mutex>, need to use a different approach
+        // For now, return a static reference based on the current state
+        use std::sync::OnceLock;
+        static AUTH_STATE_READY: AuthState = AuthState::Ready;
+        static AUTH_STATE_WAIT_PHONE: OnceLock<AuthState> = OnceLock::new();
+        static AUTH_STATE_WAIT_CODE: OnceLock<AuthState> = OnceLock::new();
+        static AUTH_STATE_WAIT_PASSWORD: OnceLock<AuthState> = OnceLock::new();
+        
+        let current = self.auth_state.lock().unwrap();
+        match *current {
+            AuthState::Ready => &AUTH_STATE_READY,
+            AuthState::WaitPhoneNumber => AUTH_STATE_WAIT_PHONE.get_or_init(|| AuthState::WaitPhoneNumber),
+            AuthState::WaitCode => AUTH_STATE_WAIT_CODE.get_or_init(|| AuthState::WaitCode),
+            AuthState::WaitPassword => AUTH_STATE_WAIT_PASSWORD.get_or_init(|| AuthState::WaitPassword),
+            _ => &AUTH_STATE_READY,
+        }
+    }
+
+    fn chats(&self) -> &[ChatInfo] {
+        // FakeTdClient uses Arc<Mutex>, can't return direct reference
+        // This is a limitation - we'll need to work around it
+        &[]
+    }
+
+    fn folders(&self) -> &[FolderInfo] {
+        &[]
+    }
+
+    fn current_chat_messages(&self) -> Vec<MessageInfo> {
+        if let Some(chat_id) = *self.current_chat_id.lock().unwrap() {
+            return self.get_messages(chat_id);
+        }
+        Vec::new()
+    }
+
+    fn current_chat_id(&self) -> Option<ChatId> {
+        self.get_current_chat_id().map(ChatId::new)
+    }
+
+    fn current_pinned_message(&self) -> Option<MessageInfo> {
+        self.current_pinned_message.lock().unwrap().clone()
+    }
+
+    fn typing_status(&self) -> Option<&(UserId, String, std::time::Instant)> {
+        None
+    }
+
+    fn pending_view_messages(&self) -> &[(ChatId, Vec<MessageId>)] {
+        &[]
+    }
+
+    fn pending_user_ids(&self) -> &[UserId] {
+        &[]
+    }
+
+    fn main_chat_list_position(&self) -> i32 {
+        0
+    }
+
+    fn user_cache(&self) -> &UserCache {
+        // Not implemented for fake - return empty cache
+        use std::sync::OnceLock;
+        static EMPTY_CACHE: OnceLock<UserCache> = OnceLock::new();
+        EMPTY_CACHE.get_or_init(|| UserCache::new(0))
+    }
+
+    fn network_state(&self) -> tele_tui::tdlib::types::NetworkState {
+        FakeTdClient::get_network_state(self)
+    }
+
+    // ============ Setters (mutable) ============
+    fn chats_mut(&mut self) -> &mut Vec<ChatInfo> {
+        // Can't return mutable reference from Arc<Mutex>
+        // This is a design limitation - we need a different approach
+        panic!("chats_mut not supported for FakeTdClient - use get_chats() instead")
+    }
+
+    fn folders_mut(&mut self) -> &mut Vec<FolderInfo> {
+        panic!("folders_mut not supported for FakeTdClient")
+    }
+
+    fn current_chat_messages_mut(&mut self) -> &mut Vec<MessageInfo> {
+        panic!("current_chat_messages_mut not supported for FakeTdClient")
+    }
+
+    fn clear_current_chat_messages(&mut self) {
+        if let Some(chat_id) = *self.current_chat_id.lock().unwrap() {
+            self.messages.lock().unwrap().remove(&chat_id);
+        }
+    }
+
+    fn set_current_chat_messages(&mut self, messages: Vec<MessageInfo>) {
+        if let Some(chat_id) = *self.current_chat_id.lock().unwrap() {
+            self.messages.lock().unwrap().insert(chat_id, messages);
+        }
+    }
+
+    fn set_current_chat_id(&mut self, chat_id: Option<ChatId>) {
+        *self.current_chat_id.lock().unwrap() = chat_id.map(|id| id.as_i64());
+    }
+
+    fn set_current_pinned_message(&mut self, msg: Option<MessageInfo>) {
+        *self.current_pinned_message.lock().unwrap() = msg;
+    }
+
+    fn set_typing_status(&mut self, _status: Option<(UserId, String, std::time::Instant)>) {
+        // Not implemented
+    }
+
+    fn pending_view_messages_mut(&mut self) -> &mut Vec<(ChatId, Vec<MessageId>)> {
+        panic!("pending_view_messages_mut not supported for FakeTdClient")
+    }
+
+    fn pending_user_ids_mut(&mut self) -> &mut Vec<UserId> {
+        panic!("pending_user_ids_mut not supported for FakeTdClient")
+    }
+
+    fn set_main_chat_list_position(&mut self, _position: i32) {
+        // Not implemented
+    }
+
+    fn user_cache_mut(&mut self) -> &mut UserCache {
+        panic!("user_cache_mut not supported for FakeTdClient")
+    }
+
+    // ============ Update handling ============
+    fn handle_update(&mut self, _update: Update) {
+        // Not implemented for fake client
+    }
+}