killingdruid/telegram-tui
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

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

Browse Source 
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>
This commit is contained in:
Mikhail Kilin
2026-02-02 05:42:19 +03:00
parent ed5a4f9c72
commit 8e48d076de
38 changed files with 1053 additions and 161 deletions
Download Patch File Download Diff File Expand all files Collapse all files

57
tests/helpers/app_builder.rs
View File

@@ -2,18 +2,14 @@
use ratatui::widgets::ListState;
use std::collections::HashMap;
use super::FakeTdClient;
use tele_tui::app::{App, AppScreen, ChatState};
use tele_tui::config::Config;
use tele_tui::tdlib::AuthState;
use tele_tui::tdlib::{ChatInfo, MessageInfo};
use tele_tui::types::{ChatId, MessageId};
/// Builder для создания тестового App
///
/// Примечание: Так как App содержит реальный TdClient,
/// этот билдер подходит только для UI/snapshot тестов.
/// Для интеграционных тестов логики понадобится рефакторинг
/// с выделением trait для TdClient.
/// Builder для создания тестового App с FakeTdClient\n///\n/// Использует trait-based DI для подмены TdClient на FakeTdClient в тестах.
pub struct TestAppBuilder {
config: Config,
screen: AppScreen,
@@ -214,13 +210,36 @@ impl TestAppBuilder {
self
}
/// Построить App
/// Построить App с FakeTdClient
///
/// ВАЖНО: Этот метод создаёт App с реальным TdClient,
/// поэтому он подходит только для UI тестов, где мы
/// не вызываем методы TdClient.
pub fn build(self) -> App {
let mut app = App::new(self.config);
/// Создаёт 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;
@@ -228,6 +247,7 @@ impl TestAppBuilder {
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;
@@ -238,11 +258,6 @@ impl TestAppBuilder {
app.status_message = Some(status);
}
// Применяем auth state
if let Some(auth_state) = self.auth_state {
app.td_client.auth.state = auth_state;
}
// Применяем auth inputs
if let Some(phone) = self.phone_input {
app.phone_input = phone;
@@ -261,14 +276,6 @@ impl TestAppBuilder {
app.chat_list_state = list_state;
}
// Применяем сообщения к текущему открытому чату
if let Some(chat_id) = self.selected_chat_id {
if let Some(messages) = self.messages.get(&chat_id) {
app.td_client.message_manager.current_chat_messages = messages.clone();
app.td_client.set_current_chat_id(Some(ChatId::new(chat_id)));
}
}
app
}
}

14
tests/helpers/fake_tdclient.rs
View File

@@ -2,7 +2,7 @@
use std::collections::HashMap;
use std::sync::{Arc, Mutex};
use tele_tui::tdlib::{ChatInfo, MessageInfo, NetworkState, ProfileInfo, ReplyInfo};
use tele_tui::tdlib::{AuthState, ChatInfo, MessageInfo, NetworkState, ProfileInfo, ReplyInfo};
use tele_tui::tdlib::types::{FolderInfo, ReactionInfo};
use tele_tui::types::{ChatId, MessageId, UserId};
use tokio::sync::mpsc;
@@ -35,6 +35,8 @@ pub struct FakeTdClient {
pub network_state: Arc<Mutex<NetworkState>>,
pub typing_chat_id: Arc<Mutex<Option<i64>>>,
pub current_chat_id: Arc<Mutex<Option<i64>>>,
pub current_pinned_message: Arc<Mutex<Option<MessageInfo>>>,
pub auth_state: Arc<Mutex<AuthState>>,
// История действий (для проверки в тестах)
pub sent_messages: Arc<Mutex<Vec<SentMessage>>>,
@@ -108,6 +110,8 @@ impl Clone for FakeTdClient {
network_state: Arc::clone(&self.network_state),
typing_chat_id: Arc::clone(&self.typing_chat_id),
current_chat_id: Arc::clone(&self.current_chat_id),
current_pinned_message: Arc::clone(&self.current_pinned_message),
auth_state: Arc::clone(&self.auth_state),
sent_messages: Arc::clone(&self.sent_messages),
edited_messages: Arc::clone(&self.edited_messages),
deleted_messages: Arc::clone(&self.deleted_messages),
@@ -138,6 +142,8 @@ impl FakeTdClient {
network_state: Arc::new(Mutex::new(NetworkState::Ready)),
typing_chat_id: Arc::new(Mutex::new(None)),
current_chat_id: Arc::new(Mutex::new(None)),
current_pinned_message: Arc::new(Mutex::new(None)),
auth_state: Arc::new(Mutex::new(AuthState::Ready)),
sent_messages: Arc::new(Mutex::new(vec![])),
edited_messages: Arc::new(Mutex::new(vec![])),
deleted_messages: Arc::new(Mutex::new(vec![])),
@@ -221,6 +227,12 @@ impl FakeTdClient {
*self.network_state.lock().unwrap() = state;
self
}
/// Установить состояние авторизации
pub fn with_auth_state(self, state: AuthState) -> Self {
*self.auth_state.lock().unwrap() = state;
self
}
/// Установить доступные реакции
pub fn with_available_reactions(self, reactions: Vec<String>) -> Self {

298
tests/helpers/fake_tdclient_impl.rs Normal file
View File

@@ -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
}
}

1
tests/helpers/mod.rs
View File

@@ -2,6 +2,7 @@
pub mod app_builder;
pub mod fake_tdclient;
mod fake_tdclient_impl; // TdClientTrait implementation for FakeTdClient
pub mod snapshot_utils;
pub mod test_data;