test_message_handler.py

"""
Unit tests for message handler.
Tests filtering direct messages and extracting sender/text.
"""
import unittest
from datetime import datetime
from unittest.mock import MagicMock


class TestMessageHandler(unittest.TestCase):
    """Test message handling functionality."""

    def test_is_direct_message_returns_true_for_direct_message(self):
        """Test that is_direct_message returns True for private messages."""
        from src.message_handler import is_direct_message

        # Mock Telegram update object with private chat
        update = MagicMock()
        update.message.chat.type = 'private'

        self.assertTrue(is_direct_message(update))

    def test_is_direct_message_returns_false_for_group_message(self):
        """Test that is_direct_message returns False for group messages."""
        from src.message_handler import is_direct_message

        # Mock Telegram update object with group chat
        update = MagicMock()
        update.message.chat.type = 'group'

        self.assertFalse(is_direct_message(update))

    def test_is_direct_message_returns_false_for_supergroup_message(self):
        """Test that is_direct_message returns False for supergroup messages."""
        from src.message_handler import is_direct_message

        # Mock Telegram update object with supergroup chat
        update = MagicMock()
        update.message.chat.type = 'supergroup'

        self.assertFalse(is_direct_message(update))

    def test_is_direct_message_returns_false_for_channel_message(self):
        """Test that is_direct_message returns False for channel messages."""
        from src.message_handler import is_direct_message

        # Mock Telegram update object with channel
        update = MagicMock()
        update.message.chat.type = 'channel'

        self.assertFalse(is_direct_message(update))

    def test_extract_sender_from_user_first_name(self):
        """Test extracting sender name from user first_name."""
        from src.message_handler import extract_sender

        update = MagicMock()
        update.message.from_user.first_name = "John"
        update.message.from_user.last_name = None

        sender = extract_sender(update)

        self.assertEqual(sender, "John")

    def test_extract_sender_from_user_first_and_last_name(self):
        """Test extracting sender with both first and last name."""
        from src.message_handler import extract_sender

        update = MagicMock()
        update.message.from_user.first_name = "John"
        update.message.from_user.last_name = "Doe"

        sender = extract_sender(update)

        self.assertEqual(sender, "John Doe")

    def test_extract_sender_uses_username_as_fallback(self):
        """Test that username is used if name is not available."""
        from src.message_handler import extract_sender

        update = MagicMock()
        update.message.from_user.first_name = None
        update.message.from_user.last_name = None
        update.message.from_user.username = "john_doe"

        sender = extract_sender(update)

        self.assertEqual(sender, "john_doe")

    def test_extract_sender_uses_user_id_as_last_fallback(self):
        """Test that user ID is used if name/username are not available."""
        from src.message_handler import extract_sender

        update = MagicMock()
        update.message.from_user.first_name = None
        update.message.from_user.last_name = None
        update.message.from_user.username = None
        update.message.from_user.id = 12345

        sender = extract_sender(update)

        self.assertEqual(sender, "12345")

    def test_extract_message_text(self):
        """Test extracting message text from update."""
        from src.message_handler import extract_message_text

        update = MagicMock()
        update.message.text = "Hello, this is a test message"

        text = extract_message_text(update)

        self.assertEqual(text, "Hello, this is a test message")

    def test_extract_message_timestamp(self):
        """Test extracting message timestamp from update."""
        from src.message_handler import extract_message_timestamp

        # Create a datetime object for comparison
        test_datetime = datetime(2026, 2, 24, 10, 30, 45)

        update = MagicMock()
        update.message.date = test_datetime

        timestamp = extract_message_timestamp(update)

        self.assertEqual(timestamp, test_datetime)

    def test_has_file_returns_false_for_text_message(self):
        """Test that has_file returns False for text-only messages."""
        from src.message_handler import has_file

        update = MagicMock()
        update.message.photo = None
        update.message.document = None
        update.message.audio = None
        update.message.video = None
        update.message.animation = None
        update.message.voice = None
        update.message.video_note = None

        self.assertFalse(has_file(update))

    def test_has_file_returns_true_for_photo(self):
        """Test that has_file returns True for photo messages."""
        from src.message_handler import has_file

        update = MagicMock()
        update.message.photo = [MagicMock()]
        update.message.document = None
        update.message.audio = None
        update.message.video = None
        update.message.animation = None
        update.message.voice = None
        update.message.video_note = None

        self.assertTrue(has_file(update))

    def test_has_file_returns_true_for_document(self):
        """Test that has_file returns True for document messages."""
        from src.message_handler import has_file

        update = MagicMock()
        update.message.photo = None
        update.message.document = MagicMock()
        update.message.audio = None
        update.message.video = None
        update.message.animation = None
        update.message.voice = None
        update.message.video_note = None

        self.assertTrue(has_file(update))

    def test_has_file_returns_true_for_audio(self):
        """Test that has_file returns True for audio messages."""
        from src.message_handler import has_file

        update = MagicMock()
        update.message.photo = None
        update.message.document = None
        update.message.audio = MagicMock()
        update.message.video = None
        update.message.animation = None
        update.message.voice = None
        update.message.video_note = None

        self.assertTrue(has_file(update))

    def test_has_file_returns_true_for_video(self):
        """Test that has_file returns True for video messages."""
        from src.message_handler import has_file

        update = MagicMock()
        update.message.photo = None
        update.message.document = None
        update.message.audio = None
        update.message.video = MagicMock()
        update.message.animation = None
        update.message.voice = None
        update.message.video_note = None

        self.assertTrue(has_file(update))

    def test_extract_file_type_photo(self):
        """Test extracting file type for photo messages."""
        from src.message_handler import extract_file_type

        update = MagicMock()
        update.message.photo = [MagicMock()]
        update.message.document = None
        update.message.audio = None
        update.message.video = None
        update.message.animation = None
        update.message.voice = None
        update.message.video_note = None

        file_type = extract_file_type(update)
        self.assertEqual(file_type, "photo")

    def test_extract_file_type_document(self):
        """Test extracting file type for document messages."""
        from src.message_handler import extract_file_type

        update = MagicMock()
        update.message.photo = None
        update.message.document = MagicMock()
        update.message.audio = None
        update.message.video = None
        update.message.animation = None
        update.message.voice = None
        update.message.video_note = None

        file_type = extract_file_type(update)
        self.assertEqual(file_type, "document")

    def test_extract_file_type_audio(self):
        """Test extracting file type for audio messages."""
        from src.message_handler import extract_file_type

        update = MagicMock()
        update.message.photo = None
        update.message.document = None
        update.message.audio = MagicMock()
        update.message.video = None
        update.message.animation = None
        update.message.voice = None
        update.message.video_note = None

        file_type = extract_file_type(update)
        self.assertEqual(file_type, "audio")

    def test_extract_file_object_photo(self):
        """Test extracting file object from photo messages (uses largest)."""
        from src.message_handler import extract_file_object

        photo_small = MagicMock()
        photo_large = MagicMock()

        update = MagicMock()
        update.message.photo = [photo_small, photo_large]
        update.message.document = None
        update.message.audio = None
        update.message.video = None
        update.message.animation = None
        update.message.voice = None
        update.message.video_note = None

        file_obj = extract_file_object(update)
        self.assertEqual(file_obj, photo_large)

    def test_extract_file_object_document(self):
        """Test extracting file object from document messages."""
        from src.message_handler import extract_file_object

        document = MagicMock()

        update = MagicMock()
        update.message.photo = None
        update.message.document = document
        update.message.audio = None
        update.message.video = None
        update.message.animation = None
        update.message.voice = None
        update.message.video_note = None

        file_obj = extract_file_object(update)
        self.assertEqual(file_obj, document)

    def test_extract_file_object_none_for_text_message(self):
        """Test extracting file object returns None for text messages."""
        from src.message_handler import extract_file_object

        update = MagicMock()
        update.message.photo = None
        update.message.document = None
        update.message.audio = None
        update.message.video = None
        update.message.animation = None
        update.message.voice = None
        update.message.video_note = None

        file_obj = extract_file_object(update)
        self.assertIsNone(file_obj)


if __name__ == '__main__':
    unittest.main()