telegram-tui/tests/send_message.rs

// Integration tests for send message flow

mod helpers;

use helpers::fake_tdclient::FakeTdClient;
use helpers::test_data::{create_test_chat, TestMessageBuilder};
use tele_tui::types::ChatId;

/// Test: Отправка текстового сообщения
#[tokio::test]
async fn test_send_text_message() {
    let client = FakeTdClient::new();
    let chat = create_test_chat("Mom", 123);
    let client = client.with_chat(chat);

    // Отправляем сообщение
    let msg = client
        .send_message(ChatId::new(123), "Hello, Mom!".to_string(), None, None)
        .await
        .unwrap();

    // Проверяем что сообщение было отправлено
    assert_eq!(client.get_sent_messages().len(), 1);
    assert_eq!(client.get_sent_messages()[0].chat_id, 123);
    assert_eq!(client.get_sent_messages()[0].text, "Hello, Mom!");
    assert_eq!(client.get_sent_messages()[0].reply_to, None);

    // Проверяем что сообщение добавилось в список
    let messages = client.get_messages(123);
    assert_eq!(messages.len(), 1);
    assert_eq!(messages[0].id(), msg.id());
    assert_eq!(messages[0].text(), "Hello, Mom!");
    assert_eq!(messages[0].is_outgoing(), true);
}

/// Test: Отправка нескольких сообщений обновляет список
#[tokio::test]
async fn test_send_multiple_messages_updates_list() {
    let client = FakeTdClient::new();

    // Отправляем первое сообщение
    let msg1 = client
        .send_message(ChatId::new(123), "Message 1".to_string(), None, None)
        .await
        .unwrap();

    // Отправляем второе сообщение
    let msg2 = client
        .send_message(ChatId::new(123), "Message 2".to_string(), None, None)
        .await
        .unwrap();

    // Отправляем третье сообщение
    let msg3 = client
        .send_message(ChatId::new(123), "Message 3".to_string(), None, None)
        .await
        .unwrap();

    // Проверяем что все 3 сообщения отслеживаются
    assert_eq!(client.get_sent_messages().len(), 3);

    // Проверяем что все сообщения в списке
    let messages = client.get_messages(123);
    assert_eq!(messages.len(), 3);
    assert_eq!(messages[0].id(), msg1.id());
    assert_eq!(messages[1].id(), msg2.id());
    assert_eq!(messages[2].id(), msg3.id());
    assert_eq!(messages[0].text(), "Message 1");
    assert_eq!(messages[1].text(), "Message 2");
    assert_eq!(messages[2].text(), "Message 3");
}

/// Test: Отправка пустого сообщения (должно быть игнорировано на уровне App)
/// Здесь мы тестируем что FakeTdClient технически может отправить пустое сообщение,
/// но в реальном App это должно фильтроваться
#[tokio::test]
async fn test_send_empty_message_technical() {
    let client = FakeTdClient::new();

    // FakeTdClient технически может отправить пустое сообщение
    let msg = client
        .send_message(ChatId::new(123), "".to_string(), None, None)
        .await
        .unwrap();

    // Проверяем что оно отправилось (в реальном App это должно фильтроваться)
    assert_eq!(client.get_sent_messages().len(), 1);
    assert_eq!(client.get_sent_messages()[0].text, "");

    let messages = client.get_messages(123);
    assert_eq!(messages.len(), 1);
    assert_eq!(messages[0].id(), msg.id());
    assert_eq!(messages[0].text(), "");
}

/// Test: Отправка сообщения с форматированием (markdown сущности)
/// В данном случае мы не проверяем парсинг markdown, только что текст сохраняется
#[tokio::test]
async fn test_send_message_with_markdown() {
    let client = FakeTdClient::new();

    let text = "**Bold** *italic* `code`";
    client
        .send_message(ChatId::new(123), text.to_string(), None, None)
        .await
        .unwrap();

    // Проверяем что текст сохранился как есть (парсинг markdown - отдельная логика)
    let messages = client.get_messages(123);
    assert_eq!(messages.len(), 1);
    assert_eq!(messages[0].text(), text);
}

/// Test: Отправка сообщения в разные чаты
#[tokio::test]
async fn test_send_messages_to_different_chats() {
    let client = FakeTdClient::new();

    // Отправляем в чат 123
    client
        .send_message(ChatId::new(123), "Hello Mom".to_string(), None, None)
        .await
        .unwrap();

    // Отправляем в чат 456
    client
        .send_message(ChatId::new(456), "Hello Boss".to_string(), None, None)
        .await
        .unwrap();

    // Отправляем ещё одно в чат 123
    client
        .send_message(ChatId::new(123), "How are you?".to_string(), None, None)
        .await
        .unwrap();

    // Проверяем общее количество отправленных
    assert_eq!(client.get_sent_messages().len(), 3);

    // Проверяем что сообщения распределены по чатам
    let chat123_messages = client.get_messages(123);
    assert_eq!(chat123_messages.len(), 2);
    assert_eq!(chat123_messages[0].text(), "Hello Mom");
    assert_eq!(chat123_messages[1].text(), "How are you?");

    let chat456_messages = client.get_messages(456);
    assert_eq!(chat456_messages.len(), 1);
    assert_eq!(chat456_messages[0].text(), "Hello Boss");
}

/// Test: Новое сообщение появляется в реальном времени (симуляция)
/// Тестируем что когда приходит новое входящее сообщение, оно добавляется в список
#[tokio::test]
async fn test_receive_incoming_message() {
    let client = FakeTdClient::new();

    // Добавляем существующее сообщение
    client
        .send_message(ChatId::new(123), "My outgoing".to_string(), None, None)
        .await
        .unwrap();

    // Симулируем входящее сообщение от собеседника
    let incoming_msg = TestMessageBuilder::new("Hey there!", 2000)
        .sender("Alice")
        .build();

    let client = client.with_message(123, incoming_msg);

    // Проверяем что в списке 2 сообщения
    let messages = client.get_messages(123);
    assert_eq!(messages.len(), 2);
    assert_eq!(messages[0].is_outgoing(), true); // Наше сообщение
    assert_eq!(messages[1].is_outgoing(), false); // Входящее
    assert_eq!(messages[1].text(), "Hey there!");
    assert_eq!(messages[1].sender_name(), "Alice");
}