Spaces:
Build error
Build error
| """Unit tests for domain exceptions.""" | |
| import pytest | |
| from src.domain.exceptions import ( | |
| DomainException, | |
| InvalidAudioFormatException, | |
| InvalidTextContentException, | |
| TranslationFailedException, | |
| SpeechRecognitionException, | |
| SpeechSynthesisException, | |
| InvalidVoiceSettingsException, | |
| AudioProcessingException | |
| ) | |
| class TestDomainExceptions: | |
| """Test cases for domain exceptions.""" | |
| def test_domain_exception_is_base_exception(self): | |
| """Test that DomainException is the base exception.""" | |
| exception = DomainException("Base domain error") | |
| assert isinstance(exception, Exception) | |
| assert str(exception) == "Base domain error" | |
| def test_domain_exception_without_message(self): | |
| """Test DomainException without message.""" | |
| exception = DomainException() | |
| assert isinstance(exception, Exception) | |
| assert str(exception) == "" | |
| def test_invalid_audio_format_exception_inheritance(self): | |
| """Test that InvalidAudioFormatException inherits from DomainException.""" | |
| exception = InvalidAudioFormatException("Invalid audio format") | |
| assert isinstance(exception, DomainException) | |
| assert isinstance(exception, Exception) | |
| assert str(exception) == "Invalid audio format" | |
| def test_invalid_audio_format_exception_usage(self): | |
| """Test InvalidAudioFormatException usage scenario.""" | |
| try: | |
| raise InvalidAudioFormatException("Unsupported format: xyz") | |
| except DomainException as e: | |
| assert "Unsupported format: xyz" in str(e) | |
| except Exception: | |
| pytest.fail("Should have caught as DomainException") | |
| def test_invalid_text_content_exception_inheritance(self): | |
| """Test that InvalidTextContentException inherits from DomainException.""" | |
| exception = InvalidTextContentException("Invalid text content") | |
| assert isinstance(exception, DomainException) | |
| assert isinstance(exception, Exception) | |
| assert str(exception) == "Invalid text content" | |
| def test_invalid_text_content_exception_usage(self): | |
| """Test InvalidTextContentException usage scenario.""" | |
| try: | |
| raise InvalidTextContentException("Text content is empty") | |
| except DomainException as e: | |
| assert "Text content is empty" in str(e) | |
| except Exception: | |
| pytest.fail("Should have caught as DomainException") | |
| def test_translation_failed_exception_inheritance(self): | |
| """Test that TranslationFailedException inherits from DomainException.""" | |
| exception = TranslationFailedException("Translation failed") | |
| assert isinstance(exception, DomainException) | |
| assert isinstance(exception, Exception) | |
| assert str(exception) == "Translation failed" | |
| def test_translation_failed_exception_usage(self): | |
| """Test TranslationFailedException usage scenario.""" | |
| try: | |
| raise TranslationFailedException("Translation service unavailable") | |
| except DomainException as e: | |
| assert "Translation service unavailable" in str(e) | |
| except Exception: | |
| pytest.fail("Should have caught as DomainException") | |
| def test_speech_recognition_exception_inheritance(self): | |
| """Test that SpeechRecognitionException inherits from DomainException.""" | |
| exception = SpeechRecognitionException("Speech recognition failed") | |
| assert isinstance(exception, DomainException) | |
| assert isinstance(exception, Exception) | |
| assert str(exception) == "Speech recognition failed" | |
| def test_speech_recognition_exception_usage(self): | |
| """Test SpeechRecognitionException usage scenario.""" | |
| try: | |
| raise SpeechRecognitionException("STT model not available") | |
| except DomainException as e: | |
| assert "STT model not available" in str(e) | |
| except Exception: | |
| pytest.fail("Should have caught as DomainException") | |
| def test_speech_synthesis_exception_inheritance(self): | |
| """Test that SpeechSynthesisException inherits from DomainException.""" | |
| exception = SpeechSynthesisException("Speech synthesis failed") | |
| assert isinstance(exception, DomainException) | |
| assert isinstance(exception, Exception) | |
| assert str(exception) == "Speech synthesis failed" | |
| def test_speech_synthesis_exception_usage(self): | |
| """Test SpeechSynthesisException usage scenario.""" | |
| try: | |
| raise SpeechSynthesisException("TTS voice not found") | |
| except DomainException as e: | |
| assert "TTS voice not found" in str(e) | |
| except Exception: | |
| pytest.fail("Should have caught as DomainException") | |
| def test_invalid_voice_settings_exception_inheritance(self): | |
| """Test that InvalidVoiceSettingsException inherits from DomainException.""" | |
| exception = InvalidVoiceSettingsException("Invalid voice settings") | |
| assert isinstance(exception, DomainException) | |
| assert isinstance(exception, Exception) | |
| assert str(exception) == "Invalid voice settings" | |
| def test_invalid_voice_settings_exception_usage(self): | |
| """Test InvalidVoiceSettingsException usage scenario.""" | |
| try: | |
| raise InvalidVoiceSettingsException("Voice speed out of range") | |
| except DomainException as e: | |
| assert "Voice speed out of range" in str(e) | |
| except Exception: | |
| pytest.fail("Should have caught as DomainException") | |
| def test_audio_processing_exception_inheritance(self): | |
| """Test that AudioProcessingException inherits from DomainException.""" | |
| exception = AudioProcessingException("Audio processing failed") | |
| assert isinstance(exception, DomainException) | |
| assert isinstance(exception, Exception) | |
| assert str(exception) == "Audio processing failed" | |
| def test_audio_processing_exception_usage(self): | |
| """Test AudioProcessingException usage scenario.""" | |
| try: | |
| raise AudioProcessingException("Pipeline validation failed") | |
| except DomainException as e: | |
| assert "Pipeline validation failed" in str(e) | |
| except Exception: | |
| pytest.fail("Should have caught as DomainException") | |
| def test_all_exceptions_inherit_from_domain_exception(self): | |
| """Test that all domain exceptions inherit from DomainException.""" | |
| exceptions = [ | |
| InvalidAudioFormatException("test"), | |
| InvalidTextContentException("test"), | |
| TranslationFailedException("test"), | |
| SpeechRecognitionException("test"), | |
| SpeechSynthesisException("test"), | |
| InvalidVoiceSettingsException("test"), | |
| AudioProcessingException("test") | |
| ] | |
| for exception in exceptions: | |
| assert isinstance(exception, DomainException) | |
| assert isinstance(exception, Exception) | |
| def test_exception_chaining_support(self): | |
| """Test that exceptions support chaining.""" | |
| original_error = ValueError("Original error") | |
| try: | |
| raise TranslationFailedException("Translation failed") from original_error | |
| except TranslationFailedException as e: | |
| assert e.__cause__ is original_error | |
| assert str(e) == "Translation failed" | |
| def test_exception_with_none_message(self): | |
| """Test exceptions with None message.""" | |
| exception = AudioProcessingException(None) | |
| assert isinstance(exception, DomainException) | |
| # Python converts None to empty string for exception messages | |
| assert str(exception) == "None" | |
| def test_exception_hierarchy_catching(self): | |
| """Test catching exceptions at different levels of hierarchy.""" | |
| # Test catching specific exception | |
| try: | |
| raise SpeechSynthesisException("TTS failed") | |
| except SpeechSynthesisException as e: | |
| assert "TTS failed" in str(e) | |
| except Exception: | |
| pytest.fail("Should have caught SpeechSynthesisException") | |
| # Test catching at domain level | |
| try: | |
| raise SpeechSynthesisException("TTS failed") | |
| except DomainException as e: | |
| assert "TTS failed" in str(e) | |
| except Exception: | |
| pytest.fail("Should have caught as DomainException") | |
| # Test catching at base level | |
| try: | |
| raise SpeechSynthesisException("TTS failed") | |
| except Exception as e: | |
| assert "TTS failed" in str(e) | |
| def test_exception_equality(self): | |
| """Test exception equality comparison.""" | |
| exc1 = AudioProcessingException("Same message") | |
| exc2 = AudioProcessingException("Same message") | |
| exc3 = AudioProcessingException("Different message") | |
| # Exceptions are not equal even with same message (different instances) | |
| assert exc1 is not exc2 | |
| assert exc1 is not exc3 | |
| # But they have the same type and message | |
| assert type(exc1) == type(exc2) | |
| assert str(exc1) == str(exc2) | |
| assert str(exc1) != str(exc3) | |
| def test_exception_repr(self): | |
| """Test exception string representation.""" | |
| exception = TranslationFailedException("Translation service error") | |
| # Test that repr includes class name and message | |
| repr_str = repr(exception) | |
| assert "TranslationFailedException" in repr_str | |
| assert "Translation service error" in repr_str | |
| def test_exception_args_property(self): | |
| """Test exception args property.""" | |
| message = "Test error message" | |
| exception = SpeechRecognitionException(message) | |
| assert exception.args == (message,) | |
| assert exception.args[0] == message |