telegram-helper-bot/tests/test_voice_exceptions.py

import pytest
from helper_bot.handlers.voice.exceptions import (
    VoiceMessageError,
    AudioProcessingError,
    VoiceBotError
)


class TestVoiceExceptions:
    """Тесты для исключений voice модуля"""
    
    def test_voice_message_error_inheritance(self):
        """Тест наследования VoiceMessageError"""
        assert issubclass(VoiceMessageError, Exception)
    
    def test_voice_message_error_message(self):
        """Тест сообщения VoiceMessageError"""
        error_message = "Тестовая ошибка голосового сообщения"
        error = VoiceMessageError(error_message)
        
        assert str(error) == error_message
        assert error.args == (error_message,)
    
    def test_voice_message_error_empty_message(self):
        """Тест VoiceMessageError с пустым сообщением"""
        error = VoiceMessageError("")
        
        assert str(error) == ""
        assert error.args == ("",)
    
    def test_voice_message_error_none_message(self):
        """Тест VoiceMessageError с None сообщением"""
        error = VoiceMessageError(None)
        
        assert str(error) == "None"
        assert error.args == (None,)
    
    def test_voice_message_error_multiple_args(self):
        """Тест VoiceMessageError с несколькими аргументами"""
        error = VoiceMessageError("Ошибка", "Дополнительная информация")
        
        assert str(error) == "('Ошибка', 'Дополнительная информация')"
        assert error.args == ("Ошибка", "Дополнительная информация")
    
    def test_audio_processing_error_inheritance(self):
        """Тест наследования AudioProcessingError"""
        assert issubclass(AudioProcessingError, Exception)
    
    def test_audio_processing_error_message(self):
        """Тест сообщения AudioProcessingError"""
        error_message = "Ошибка обработки аудио файла"
        error = AudioProcessingError(error_message)
        
        assert str(error) == error_message
        assert error.args == (error_message,)
    
    def test_audio_processing_error_empty_message(self):
        """Тест AudioProcessingError с пустым сообщением"""
        error = AudioProcessingError("")
        
        assert str(error) == ""
        assert error.args == ("",)
    
    def test_audio_processing_error_none_message(self):
        """Тест AudioProcessingError с None сообщением"""
        error = AudioProcessingError(None)
        
        assert str(error) == "None"
        assert error.args == (None,)
    
    def test_voice_bot_error_inheritance(self):
        """Тест наследования VoiceBotError"""
        assert issubclass(VoiceBotError, Exception)
    
    def test_voice_bot_error_message(self):
        """Тест сообщения VoiceBotError"""
        error_message = "Общая ошибка voice бота"
        error = VoiceBotError(error_message)
        
        assert str(error) == error_message
        assert error.args == (error_message,)
    
    def test_exception_hierarchy(self):
        """Тест иерархии исключений"""
        # Проверяем, что все исключения наследуются от Exception
        assert issubclass(VoiceMessageError, Exception)
        assert issubclass(AudioProcessingError, Exception)
        assert issubclass(VoiceBotError, Exception)
        
        # Проверяем, что VoiceMessageError и AudioProcessingError наследуются от VoiceBotError
        assert issubclass(VoiceMessageError, VoiceBotError)
        assert issubclass(AudioProcessingError, VoiceBotError)
        
        # Проверяем, что VoiceBotError не наследуется от других исключений
        assert not issubclass(VoiceBotError, VoiceMessageError)
        assert not issubclass(VoiceBotError, AudioProcessingError)
        
        # Проверяем, что VoiceMessageError и AudioProcessingError не наследуются друг от друга
        assert not issubclass(VoiceMessageError, AudioProcessingError)
        assert not issubclass(AudioProcessingError, VoiceMessageError)
    
    def test_exception_creation_without_args(self):
        """Тест создания исключений без аргументов"""
        # Должно работать без аргументов
        voice_error = VoiceMessageError()
        audio_error = AudioProcessingError()
        bot_error = VoiceBotError()
        
        assert str(voice_error) == ""
        assert str(audio_error) == ""
        assert str(bot_error) == ""
    
    def test_exception_creation_with_int(self):
        """Тест создания исключений с числовыми аргументами"""
        voice_error = VoiceMessageError(123)
        audio_error = AudioProcessingError(456)
        bot_error = VoiceBotError(789)
        
        assert str(voice_error) == "123"
        assert str(audio_error) == "456"
        assert str(bot_error) == "789"
    
    def test_exception_creation_with_list(self):
        """Тест создания исключений со списками"""
        error_list = ["Ошибка 1", "Ошибка 2"]
        voice_error = VoiceMessageError(error_list)
        audio_error = AudioProcessingError(error_list)
        bot_error = VoiceBotError(error_list)
        
        assert str(voice_error) == str(error_list)
        assert str(audio_error) == str(error_list)
        assert str(bot_error) == str(error_list)
    
    def test_exception_creation_with_dict(self):
        """Тест создания исключений со словарями"""
        error_dict = {"code": 500, "message": "Internal error"}
        voice_error = VoiceMessageError(error_dict)
        audio_error = AudioProcessingError(error_dict)
        bot_error = VoiceBotError(error_dict)
        
        assert str(voice_error) == str(error_dict)
        assert str(audio_error) == str(error_dict)
        assert str(bot_error) == str(error_dict)
    
    def test_exception_attributes(self):
        """Тест атрибутов исключений"""
        error_message = "Тестовая ошибка"
        voice_error = VoiceMessageError(error_message)
        audio_error = AudioProcessingError(error_message)
        bot_error = VoiceBotError(error_message)
        
        # Проверяем, что исключения имеют атрибут args
        assert hasattr(voice_error, 'args')
        assert hasattr(audio_error, 'args')
        assert hasattr(bot_error, 'args')
        
        # Проверяем, что args содержит переданное сообщение
        assert voice_error.args == (error_message,)
        assert audio_error.args == (error_message,)
        assert bot_error.args == (error_message,)
    
    def test_exception_string_representation(self):
        """Тест строкового представления исключений"""
        error_message = "Тестовая ошибка"
        voice_error = VoiceMessageError(error_message)
        audio_error = AudioProcessingError(error_message)
        bot_error = VoiceBotError(error_message)
        
        # Проверяем, что str() возвращает сообщение
        assert str(voice_error) == error_message
        assert str(audio_error) == error_message
        assert str(bot_error) == error_message
        
        # Проверяем, что repr() содержит имя класса
        assert "VoiceMessageError" in repr(voice_error)
        assert "AudioProcessingError" in repr(audio_error)
        assert "VoiceBotError" in repr(bot_error)
    
    def test_exception_equality(self):
        """Тест равенства исключений"""
        error1 = VoiceMessageError("Ошибка")
        error2 = VoiceMessageError("Ошибка")
        error3 = VoiceMessageError("Другая ошибка")
        
        # Исключения с одинаковыми сообщениями не равны (разные объекты)
        assert error1 != error2
        assert error1 != error3
        
        # Но их строковые представления равны
        assert str(error1) == str(error2)
        assert str(error1) != str(error3)
    
    def test_exception_inheritance_chain(self):
        """Тест цепочки наследования исключений"""
        # Проверяем, что все исключения являются экземплярами Exception
        voice_error = VoiceMessageError("Ошибка")
        audio_error = AudioProcessingError("Ошибка")
        bot_error = VoiceBotError("Ошибка")
        
        assert isinstance(voice_error, Exception)
        assert isinstance(audio_error, Exception)
        assert isinstance(bot_error, Exception)
        
        # Проверяем, что исключения являются экземплярами своих классов
        assert isinstance(voice_error, VoiceMessageError)
        assert isinstance(audio_error, AudioProcessingError)
        assert isinstance(bot_error, VoiceBotError)


if __name__ == '__main__':
    pytest.main([__file__])