265 lines
8.0 KiB
Rust
265 lines
8.0 KiB
Rust
// Fake TDLib client for testing
|
|
|
|
use std::collections::HashMap;
|
|
use tele_tui::tdlib::{ChatInfo, FolderInfo, MessageInfo, NetworkState};
|
|
|
|
/// Упрощённый mock TDLib клиента для тестов
|
|
#[derive(Clone)]
|
|
pub struct FakeTdClient {
|
|
pub chats: Vec<ChatInfo>,
|
|
pub messages: HashMap<i64, Vec<MessageInfo>>,
|
|
pub folders: Vec<FolderInfo>,
|
|
pub user_names: HashMap<i64, String>,
|
|
pub network_state: NetworkState,
|
|
pub typing_chat_id: Option<i64>,
|
|
pub sent_messages: Vec<SentMessage>,
|
|
pub edited_messages: Vec<EditedMessage>,
|
|
pub deleted_messages: Vec<i64>,
|
|
pub reactions: HashMap<i64, Vec<String>>, // message_id -> emojis
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub struct SentMessage {
|
|
pub chat_id: i64,
|
|
pub text: String,
|
|
pub reply_to: Option<i64>,
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub struct EditedMessage {
|
|
pub message_id: i64,
|
|
pub new_text: String,
|
|
}
|
|
|
|
impl Default for FakeTdClient {
|
|
fn default() -> Self {
|
|
Self::new()
|
|
}
|
|
}
|
|
|
|
impl FakeTdClient {
|
|
pub fn new() -> Self {
|
|
Self {
|
|
chats: vec![],
|
|
messages: HashMap::new(),
|
|
folders: vec![FolderInfo { id: 0, name: "All".to_string() }],
|
|
user_names: HashMap::new(),
|
|
network_state: NetworkState::Ready,
|
|
typing_chat_id: None,
|
|
sent_messages: vec![],
|
|
edited_messages: vec![],
|
|
deleted_messages: vec![],
|
|
reactions: HashMap::new(),
|
|
}
|
|
}
|
|
|
|
/// Добавить чат
|
|
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 with_message(mut self, chat_id: i64, message: MessageInfo) -> Self {
|
|
self.messages
|
|
.entry(chat_id)
|
|
.or_insert_with(Vec::new)
|
|
.push(message);
|
|
self
|
|
}
|
|
|
|
/// Добавить несколько сообщений в чат
|
|
pub fn with_messages(mut self, chat_id: i64, messages: Vec<MessageInfo>) -> Self {
|
|
self.messages
|
|
.entry(chat_id)
|
|
.or_insert_with(Vec::new)
|
|
.extend(messages);
|
|
self
|
|
}
|
|
|
|
/// Добавить папку
|
|
pub fn with_folder(mut self, id: i32, name: &str) -> Self {
|
|
self.folders.push(FolderInfo { id, name: name.to_string() });
|
|
self
|
|
}
|
|
|
|
/// Добавить пользователя
|
|
pub fn with_user(mut self, id: i64, name: &str) -> Self {
|
|
self.user_names.insert(id, name.to_string());
|
|
self
|
|
}
|
|
|
|
/// Установить состояние сети
|
|
pub fn with_network_state(mut self, state: NetworkState) -> Self {
|
|
self.network_state = state;
|
|
self
|
|
}
|
|
|
|
/// Получить чаты
|
|
pub fn get_chats(&self) -> &[ChatInfo] {
|
|
&self.chats
|
|
}
|
|
|
|
/// Получить сообщения для чата
|
|
pub fn get_messages(&self, chat_id: i64) -> Vec<MessageInfo> {
|
|
self.messages.get(&chat_id).cloned().unwrap_or_default()
|
|
}
|
|
|
|
/// Получить папки
|
|
pub fn get_folders(&self) -> &[FolderInfo] {
|
|
&self.folders
|
|
}
|
|
|
|
/// Отправить сообщение (мок)
|
|
pub fn send_message(&mut self, chat_id: i64, text: String, reply_to: Option<i64>) -> i64 {
|
|
let message_id = (self.sent_messages.len() as i64) + 1000;
|
|
|
|
self.sent_messages
|
|
.push(SentMessage { chat_id, text: text.clone(), reply_to });
|
|
|
|
// Добавляем сообщение в список сообщений чата
|
|
let message = MessageInfo {
|
|
id: message_id,
|
|
sender_name: "You".to_string(),
|
|
is_outgoing: true,
|
|
content: text,
|
|
entities: vec![],
|
|
date: 1640000000,
|
|
edit_date: 0,
|
|
is_read: true,
|
|
can_be_edited: true,
|
|
can_be_deleted_only_for_self: true,
|
|
can_be_deleted_for_all_users: true,
|
|
reply_to: None,
|
|
forward_from: None,
|
|
reactions: vec![],
|
|
};
|
|
|
|
self.messages
|
|
.entry(chat_id)
|
|
.or_insert_with(Vec::new)
|
|
.push(message);
|
|
|
|
message_id
|
|
}
|
|
|
|
/// Редактировать сообщение (мок)
|
|
pub fn edit_message(&mut self, chat_id: i64, message_id: i64, new_text: String) {
|
|
self.edited_messages
|
|
.push(EditedMessage { message_id, new_text: new_text.clone() });
|
|
|
|
// Обновляем сообщение в списке
|
|
if let Some(messages) = self.messages.get_mut(&chat_id) {
|
|
if let Some(msg) = messages.iter_mut().find(|m| m.id == message_id) {
|
|
msg.content = new_text;
|
|
msg.edit_date = msg.date + 60;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Удалить сообщение (мок)
|
|
pub fn delete_message(&mut self, chat_id: i64, message_id: i64) {
|
|
self.deleted_messages.push(message_id);
|
|
|
|
// Удаляем сообщение из списка
|
|
if let Some(messages) = self.messages.get_mut(&chat_id) {
|
|
messages.retain(|m| m.id != message_id);
|
|
}
|
|
}
|
|
|
|
/// Добавить реакцию (мок)
|
|
pub fn add_reaction(&mut self, message_id: i64, emoji: String) {
|
|
self.reactions
|
|
.entry(message_id)
|
|
.or_insert_with(Vec::new)
|
|
.push(emoji);
|
|
}
|
|
|
|
/// Установить статус "печатает"
|
|
pub fn set_typing(&mut self, chat_id: Option<i64>) {
|
|
self.typing_chat_id = chat_id;
|
|
}
|
|
|
|
/// Получить список отправленных сообщений
|
|
pub fn sent_messages(&self) -> &[SentMessage] {
|
|
&self.sent_messages
|
|
}
|
|
|
|
/// Получить список отредактированных сообщений
|
|
pub fn edited_messages(&self) -> &[EditedMessage] {
|
|
&self.edited_messages
|
|
}
|
|
|
|
/// Получить список удалённых сообщений
|
|
pub fn deleted_messages(&self) -> &[i64] {
|
|
&self.deleted_messages
|
|
}
|
|
|
|
/// Очистить историю действий
|
|
pub fn clear_history(&mut self) {
|
|
self.sent_messages.clear();
|
|
self.edited_messages.clear();
|
|
self.deleted_messages.clear();
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
use crate::helpers::test_data::create_test_chat;
|
|
|
|
#[test]
|
|
fn test_fake_client_creation() {
|
|
let client = FakeTdClient::new();
|
|
assert_eq!(client.chats.len(), 0);
|
|
assert_eq!(client.folders.len(), 1); // Default "All" folder
|
|
}
|
|
|
|
#[test]
|
|
fn test_fake_client_with_chat() {
|
|
let chat = create_test_chat("Mom", 123);
|
|
let client = FakeTdClient::new().with_chat(chat);
|
|
|
|
assert_eq!(client.chats.len(), 1);
|
|
assert_eq!(client.chats[0].title, "Mom");
|
|
}
|
|
|
|
#[test]
|
|
fn test_send_message() {
|
|
let mut client = FakeTdClient::new();
|
|
let msg_id = client.send_message(123, "Hello".to_string(), None);
|
|
|
|
assert_eq!(client.sent_messages().len(), 1);
|
|
assert_eq!(client.sent_messages()[0].text, "Hello");
|
|
assert_eq!(client.get_messages(123).len(), 1);
|
|
assert_eq!(client.get_messages(123)[0].id, msg_id);
|
|
}
|
|
|
|
#[test]
|
|
fn test_edit_message() {
|
|
let mut client = FakeTdClient::new();
|
|
let msg_id = client.send_message(123, "Hello".to_string(), None);
|
|
client.edit_message(123, msg_id, "Hello World".to_string());
|
|
|
|
assert_eq!(client.edited_messages().len(), 1);
|
|
assert_eq!(client.get_messages(123)[0].content, "Hello World");
|
|
assert!(client.get_messages(123)[0].edit_date > 0);
|
|
}
|
|
|
|
#[test]
|
|
fn test_delete_message() {
|
|
let mut client = FakeTdClient::new();
|
|
let msg_id = client.send_message(123, "Hello".to_string(), None);
|
|
client.delete_message(123, msg_id);
|
|
|
|
assert_eq!(client.deleted_messages().len(), 1);
|
|
assert_eq!(client.get_messages(123).len(), 0);
|
|
}
|
|
}
|