Create unit tests for domain layer

tests/unit/domain/interfaces/__init__.py

@@ -0,0 +1 @@
+# Domain interface tests

tests/unit/domain/interfaces/test_audio_processing.py

@@ -0,0 +1,212 @@
+"""Unit tests for IAudioProcessingService interface contract."""
+
+import pytest
+from abc import ABC
+from unittest.mock import Mock
+from src.domain.interfaces.audio_processing import IAudioProcessingService
+from src.domain.models.audio_content import AudioContent
+from src.domain.models.voice_settings import VoiceSettings
+from src.domain.models.processing_result import ProcessingResult
+from src.domain.models.text_content import TextContent
+
+
+class TestIAudioProcessingService:
+    """Test cases for IAudioProcessingService interface contract."""
+
+    def test_interface_is_abstract(self):
+        """Test that IAudioProcessingService is an abstract base class."""
+        assert issubclass(IAudioProcessingService, ABC)
+
+        # Should not be able to instantiate directly
+        with pytest.raises(TypeError):
+            IAudioProcessingService()  # type: ignore
+
+    def test_interface_has_required_method(self):
+        """Test that interface defines the required abstract method."""
+        # Check that the method exists and is abstract
+        assert hasattr(IAudioProcessingService, 'process_audio_pipeline')
+        assert getattr(IAudioProcessingService.process_audio_pipeline, '__isabstractmethod__', False)
+
+    def test_method_signature(self):
+        """Test that the method has the correct signature."""
+        import inspect
+
+        method = IAudioProcessingService.process_audio_pipeline
+        signature = inspect.signature(method)
+
+        # Check parameter names and types
+        params = list(signature.parameters.keys())
+        expected_params = ['self', 'audio', 'target_language', 'voice_settings']
+
+        assert params == expected_params
+
+        # Check return annotation
+        assert signature.return_annotation == "'ProcessingResult'"
+
+    def test_concrete_implementation_must_implement_method(self):
+        """Test that concrete implementations must implement the abstract method."""
+
+        class IncompleteImplementation(IAudioProcessingService):
+            pass
+
+        # Should not be able to instantiate without implementing abstract method
+        with pytest.raises(TypeError, match="Can't instantiate abstract class"):
+            IncompleteImplementation()  # type: ignore
+
+    def test_concrete_implementation_with_method(self):
+        """Test that concrete implementation with method can be instantiated."""
+
+        class ConcreteImplementation(IAudioProcessingService):
+            def process_audio_pipeline(self, audio, target_language, voice_settings):
+                return ProcessingResult.success_result(
+                    original_text=TextContent(text="test", language="en")
+                )
+
+        # Should be able to instantiate
+        implementation = ConcreteImplementation()
+        assert isinstance(implementation, IAudioProcessingService)
+
+    def test_method_contract_with_mock(self):
+        """Test the method contract using a mock implementation."""
+
+        class MockImplementation(IAudioProcessingService):
+            def __init__(self):
+                self.mock_method = Mock()
+
+            def process_audio_pipeline(self, audio, target_language, voice_settings):
+                return self.mock_method(audio, target_language, voice_settings)
+
+        # Create test data
+        audio = AudioContent(
+            data=b"test_audio",
+            format="wav",
+            sample_rate=22050,
+            duration=5.0
+        )
+        voice_settings = VoiceSettings(
+            voice_id="test_voice",
+            speed=1.0,
+            language="es"
+        )
+        expected_result = ProcessingResult.success_result(
+            original_text=TextContent(text="test", language="en")
+        )
+
+        # Setup mock
+        implementation = MockImplementation()
+        implementation.mock_method.return_value = expected_result
+
+        # Call method
+        result = implementation.process_audio_pipeline(
+            audio=audio,
+            target_language="es",
+            voice_settings=voice_settings
+        )
+
+        # Verify call and result
+        implementation.mock_method.assert_called_once_with(audio, "es", voice_settings)
+        assert result == expected_result
+
+    def test_interface_docstring_requirements(self):
+        """Test that the interface method has proper documentation."""
+        method = IAudioProcessingService.process_audio_pipeline
+
+        assert method.__doc__ is not None
+        docstring = method.__doc__
+
+        # Check that docstring contains key information
+        assert "Process audio through the complete pipeline" in docstring
+        assert "STT -> Translation -> TTS" in docstring
+        assert "Args:" in docstring
+        assert "Returns:" in docstring
+        assert "Raises:" in docstring
+        assert "AudioProcessingException" in docstring
+
+    def test_interface_type_hints(self):
+        """Test that the interface uses proper type hints."""
+        import inspect
+        from typing import get_type_hints
+
+        # Get type hints (this will resolve string annotations)
+        try:
+            hints = get_type_hints(IAudioProcessingService.process_audio_pipeline)
+        except NameError:
+            # If forward references can't be resolved, check annotations directly
+            method = IAudioProcessingService.process_audio_pipeline
+            annotations = getattr(method, '__annotations__', {})
+
+            assert 'audio' in annotations
+            assert 'target_language' in annotations
+            assert 'voice_settings' in annotations
+            assert 'return' in annotations
+
+            # Check that type annotations are strings (forward references)
+            assert annotations['audio'] == "'AudioContent'"
+            assert annotations['target_language'] == str
+            assert annotations['voice_settings'] == "'VoiceSettings'"
+            assert annotations['return'] == "'ProcessingResult'"
+
+    def test_multiple_implementations_possible(self):
+        """Test that multiple implementations of the interface are possible."""
+
+        class Implementation1(IAudioProcessingService):
+            def process_audio_pipeline(self, audio, target_language, voice_settings):
+                return ProcessingResult.success_result(
+                    original_text=TextContent(text="impl1", language="en")
+                )
+
+        class Implementation2(IAudioProcessingService):
+            def process_audio_pipeline(self, audio, target_language, voice_settings):
+                return ProcessingResult.failure_result(error_message="impl2 failed")
+
+        impl1 = Implementation1()
+        impl2 = Implementation2()
+
+        assert isinstance(impl1, IAudioProcessingService)
+        assert isinstance(impl2, IAudioProcessingService)
+        assert type(impl1) != type(impl2)
+
+    def test_interface_method_can_be_called_polymorphically(self):
+        """Test that interface methods can be called polymorphically."""
+
+        class TestImplementation(IAudioProcessingService):
+            def __init__(self, result):
+                self.result = result
+
+            def process_audio_pipeline(self, audio, target_language, voice_settings):
+                return self.result
+
+        # Create different implementations
+        success_result = ProcessingResult.success_result(
+            original_text=TextContent(text="success", language="en")
+        )
+        failure_result = ProcessingResult.failure_result(error_message="failed")
+
+        implementations = [
+            TestImplementation(success_result),
+            TestImplementation(failure_result)
+        ]
+
+        # Test polymorphic usage
+        audio = AudioContent(data=b"test", format="wav", sample_rate=22050, duration=1.0)
+        voice_settings = VoiceSettings(voice_id="test", speed=1.0, language="en")
+
+        results = []
+        for impl in implementations:
+            # Can call the same method on different implementations
+            result = impl.process_audio_pipeline(audio, "en", voice_settings)
+            results.append(result)
+
+        assert len(results) == 2
+        assert results[0].success is True
+        assert results[1].success is False
+
+    def test_interface_inheritance_chain(self):
+        """Test the inheritance chain of the interface."""
+        # Check that it inherits from ABC
+        assert ABC in IAudioProcessingService.__mro__
+
+        # Check that it's at the right position in MRO
+        mro = IAudioProcessingService.__mro__
+        assert mro[0] == IAudioProcessingService
+        assert ABC in mro

tests/unit/domain/interfaces/test_speech_recognition.py

@@ -0,0 +1,241 @@
+"""Unit tests for ISpeechRecognitionService interface contract."""
+
+import pytest
+from abc import ABC
+from unittest.mock import Mock
+from src.domain.interfaces.speech_recognition import ISpeechRecognitionService
+from src.domain.models.audio_content import AudioContent
+from src.domain.models.text_content import TextContent
+
+
+class TestISpeechRecognitionService:
+    """Test cases for ISpeechRecognitionService interface contract."""
+
+    def test_interface_is_abstract(self):
+        """Test that ISpeechRecognitionService is an abstract base class."""
+        assert issubclass(ISpeechRecognitionService, ABC)
+
+        # Should not be able to instantiate directly
+        with pytest.raises(TypeError):
+            ISpeechRecognitionService()  # type: ignore
+
+    def test_interface_has_required_method(self):
+        """Test that interface defines the required abstract method."""
+        # Check that the method exists and is abstract
+        assert hasattr(ISpeechRecognitionService, 'transcribe')
+        assert getattr(ISpeechRecognitionService.transcribe, '__isabstractmethod__', False)
+
+    def test_method_signature(self):
+        """Test that the method has the correct signature."""
+        import inspect
+
+        method = ISpeechRecognitionService.transcribe
+        signature = inspect.signature(method)
+
+        # Check parameter names
+        params = list(signature.parameters.keys())
+        expected_params = ['self', 'audio', 'model']
+
+        assert params == expected_params
+
+        # Check return annotation
+        assert signature.return_annotation == "'TextContent'"
+
+    def test_concrete_implementation_must_implement_method(self):
+        """Test that concrete implementations must implement the abstract method."""
+
+        class IncompleteImplementation(ISpeechRecognitionService):
+            pass
+
+        # Should not be able to instantiate without implementing abstract method
+        with pytest.raises(TypeError, match="Can't instantiate abstract class"):
+            IncompleteImplementation()  # type: ignore
+
+    def test_concrete_implementation_with_method(self):
+        """Test that concrete implementation with method can be instantiated."""
+
+        class ConcreteImplementation(ISpeechRecognitionService):
+            def transcribe(self, audio, model):
+                return TextContent(text="transcribed text", language="en")
+
+        # Should be able to instantiate
+        implementation = ConcreteImplementation()
+        assert isinstance(implementation, ISpeechRecognitionService)
+
+    def test_method_contract_with_mock(self):
+        """Test the method contract using a mock implementation."""
+
+        class MockImplementation(ISpeechRecognitionService):
+            def __init__(self):
+                self.mock_method = Mock()
+
+            def transcribe(self, audio, model):
+                return self.mock_method(audio, model)
+
+        # Create test data
+        audio = AudioContent(
+            data=b"test_audio",
+            format="wav",
+            sample_rate=22050,
+            duration=5.0
+        )
+        model = "whisper-base"
+        expected_result = TextContent(text="Hello world", language="en")
+
+        # Setup mock
+        implementation = MockImplementation()
+        implementation.mock_method.return_value = expected_result
+
+        # Call method
+        result = implementation.transcribe(audio=audio, model=model)
+
+        # Verify call and result
+        implementation.mock_method.assert_called_once_with(audio, model)
+        assert result == expected_result
+
+    def test_interface_docstring_requirements(self):
+        """Test that the interface method has proper documentation."""
+        method = ISpeechRecognitionService.transcribe
+
+        assert method.__doc__ is not None
+        docstring = method.__doc__
+
+        # Check that docstring contains key information
+        assert "Transcribe audio content to text" in docstring
+        assert "Args:" in docstring
+        assert "Returns:" in docstring
+        assert "Raises:" in docstring
+        assert "SpeechRecognitionException" in docstring
+
+    def test_interface_type_hints(self):
+        """Test that the interface uses proper type hints."""
+        method = ISpeechRecognitionService.transcribe
+        annotations = getattr(method, '__annotations__', {})
+
+        assert 'audio' in annotations
+        assert 'model' in annotations
+        assert 'return' in annotations
+
+        # Check that type annotations are correct
+        assert annotations['audio'] == "'AudioContent'"
+        assert annotations['model'] == str
+        assert annotations['return'] == "'TextContent'"
+
+    def test_multiple_implementations_possible(self):
+        """Test that multiple implementations of the interface are possible."""
+
+        class WhisperImplementation(ISpeechRecognitionService):
+            def transcribe(self, audio, model):
+                return TextContent(text="whisper transcription", language="en")
+
+        class ParakeetImplementation(ISpeechRecognitionService):
+            def transcribe(self, audio, model):
+                return TextContent(text="parakeet transcription", language="en")
+
+        whisper = WhisperImplementation()
+        parakeet = ParakeetImplementation()
+
+        assert isinstance(whisper, ISpeechRecognitionService)
+        assert isinstance(parakeet, ISpeechRecognitionService)
+        assert type(whisper) != type(parakeet)
+
+    def test_interface_method_can_be_called_polymorphically(self):
+        """Test that interface methods can be called polymorphically."""
+
+        class TestImplementation(ISpeechRecognitionService):
+            def __init__(self, transcription_text):
+                self.transcription_text = transcription_text
+
+            def transcribe(self, audio, model):
+                return TextContent(text=self.transcription_text, language="en")
+
+        # Create different implementations
+        implementations = [
+            TestImplementation("first transcription"),
+            TestImplementation("second transcription")
+        ]
+
+        # Test polymorphic usage
+        audio = AudioContent(data=b"test", format="wav", sample_rate=22050, duration=1.0)
+        model = "test-model"
+
+        results = []
+        for impl in implementations:
+            # Can call the same method on different implementations
+            result = impl.transcribe(audio, model)
+            results.append(result.text)
+
+        assert results == ["first transcription", "second transcription"]
+
+    def test_interface_inheritance_chain(self):
+        """Test the inheritance chain of the interface."""
+        # Check that it inherits from ABC
+        assert ABC in ISpeechRecognitionService.__mro__
+
+        # Check that it's at the right position in MRO
+        mro = ISpeechRecognitionService.__mro__
+        assert mro[0] == ISpeechRecognitionService
+        assert ABC in mro
+
+    def test_method_parameter_validation_in_implementation(self):
+        """Test that implementations can validate parameters."""
+
+        class ValidatingImplementation(ISpeechRecognitionService):
+            def transcribe(self, audio, model):
+                if not isinstance(audio, AudioContent):
+                    raise TypeError("audio must be AudioContent")
+                if not isinstance(model, str):
+                    raise TypeError("model must be string")
+                if not model.strip():
+                    raise ValueError("model cannot be empty")
+
+                return TextContent(text="validated transcription", language="en")
+
+        impl = ValidatingImplementation()
+
+        # Valid call should work
+        audio = AudioContent(data=b"test", format="wav", sample_rate=22050, duration=1.0)
+        result = impl.transcribe(audio, "whisper-base")
+        assert result.text == "validated transcription"
+
+        # Invalid calls should raise appropriate errors
+        with pytest.raises(TypeError, match="audio must be AudioContent"):
+            impl.transcribe("not audio", "whisper-base")  # type: ignore
+
+        with pytest.raises(TypeError, match="model must be string"):
+            impl.transcribe(audio, 123)  # type: ignore
+
+        with pytest.raises(ValueError, match="model cannot be empty"):
+            impl.transcribe(audio, "")
+
+    def test_implementation_can_handle_different_models(self):
+        """Test that implementations can handle different model types."""
+
+        class MultiModelImplementation(ISpeechRecognitionService):
+            def transcribe(self, audio, model):
+                model_responses = {
+                    "whisper-tiny": "tiny transcription",
+                    "whisper-base": "base transcription",
+                    "whisper-large": "large transcription",
+                    "parakeet": "parakeet transcription"
+                }
+
+                transcription = model_responses.get(model, "unknown model transcription")
+                return TextContent(text=transcription, language="en")
+
+        impl = MultiModelImplementation()
+        audio = AudioContent(data=b"test", format="wav", sample_rate=22050, duration=1.0)
+
+        # Test different models
+        models_and_expected = [
+            ("whisper-tiny", "tiny transcription"),
+            ("whisper-base", "base transcription"),
+            ("whisper-large", "large transcription"),
+            ("parakeet", "parakeet transcription"),
+            ("unknown-model", "unknown model transcription")
+        ]
+
+        for model, expected_text in models_and_expected:
+            result = impl.transcribe(audio, model)
+            assert result.text == expected_text
+            assert result.language == "en"

tests/unit/domain/interfaces/test_speech_synthesis.py

@@ -0,0 +1,378 @@
+"""Unit tests for ISpeechSynthesisService interface contract."""
+
+import pytest
+from abc import ABC
+from unittest.mock import Mock
+from typing import Iterator
+from src.domain.interfaces.speech_synthesis import ISpeechSynthesisService
+from src.domain.models.speech_synthesis_request import SpeechSynthesisRequest
+from src.domain.models.audio_content import AudioContent
+from src.domain.models.audio_chunk import AudioChunk
+from src.domain.models.text_content import TextContent
+from src.domain.models.voice_settings import VoiceSettings
+
+
+class TestISpeechSynthesisService:
+    """Test cases for ISpeechSynthesisService interface contract."""
+
+    def test_interface_is_abstract(self):
+        """Test that ISpeechSynthesisService is an abstract base class."""
+        assert issubclass(ISpeechSynthesisService, ABC)
+
+        # Should not be able to instantiate directly
+        with pytest.raises(TypeError):
+            ISpeechSynthesisService()  # type: ignore
+
+    def test_interface_has_required_methods(self):
+        """Test that interface defines the required abstract methods."""
+        # Check that both methods exist and are abstract
+        assert hasattr(ISpeechSynthesisService, 'synthesize')
+        assert hasattr(ISpeechSynthesisService, 'synthesize_stream')
+
+        assert getattr(ISpeechSynthesisService.synthesize, '__isabstractmethod__', False)
+        assert getattr(ISpeechSynthesisService.synthesize_stream, '__isabstractmethod__', False)
+
+    def test_synthesize_method_signature(self):
+        """Test that the synthesize method has the correct signature."""
+        import inspect
+
+        method = ISpeechSynthesisService.synthesize
+        signature = inspect.signature(method)
+
+        # Check parameter names
+        params = list(signature.parameters.keys())
+        expected_params = ['self', 'request']
+
+        assert params == expected_params
+
+        # Check return annotation
+        assert signature.return_annotation == "'AudioContent'"
+
+    def test_synthesize_stream_method_signature(self):
+        """Test that the synthesize_stream method has the correct signature."""
+        import inspect
+
+        method = ISpeechSynthesisService.synthesize_stream
+        signature = inspect.signature(method)
+
+        # Check parameter names
+        params = list(signature.parameters.keys())
+        expected_params = ['self', 'request']
+
+        assert params == expected_params
+
+        # Check return annotation
+        assert signature.return_annotation == "Iterator['AudioChunk']"
+
+    def test_concrete_implementation_must_implement_methods(self):
+        """Test that concrete implementations must implement both abstract methods."""
+
+        class IncompleteImplementation(ISpeechSynthesisService):
+            def synthesize(self, request):
+                return AudioContent(data=b"test", format="wav", sample_rate=22050, duration=1.0)
+            # Missing synthesize_stream method
+
+        # Should not be able to instantiate without implementing all abstract methods
+        with pytest.raises(TypeError, match="Can't instantiate abstract class"):
+            IncompleteImplementation()  # type: ignore
+
+    def test_concrete_implementation_with_both_methods(self):
+        """Test that concrete implementation with both methods can be instantiated."""
+
+        class ConcreteImplementation(ISpeechSynthesisService):
+            def synthesize(self, request):
+                return AudioContent(data=b"synthesized", format="wav", sample_rate=22050, duration=1.0)
+
+            def synthesize_stream(self, request):
+                yield AudioChunk(data=b"chunk1", format="wav", sample_rate=22050, chunk_index=0, is_final=True)
+
+        # Should be able to instantiate
+        implementation = ConcreteImplementation()
+        assert isinstance(implementation, ISpeechSynthesisService)
+
+    def test_synthesize_method_contract_with_mock(self):
+        """Test the synthesize method contract using a mock implementation."""
+
+        class MockImplementation(ISpeechSynthesisService):
+            def __init__(self):
+                self.mock_synthesize = Mock()
+                self.mock_synthesize_stream = Mock()
+
+            def synthesize(self, request):
+                return self.mock_synthesize(request)
+
+            def synthesize_stream(self, request):
+                return self.mock_synthesize_stream(request)
+
+        # Create test data
+        text_content = TextContent(text="Hello world", language="en")
+        voice_settings = VoiceSettings(voice_id="test_voice", speed=1.0, language="en")
+        request = SpeechSynthesisRequest(
+            text_content=text_content,
+            voice_settings=voice_settings
+        )
+        expected_result = AudioContent(
+            data=b"synthesized_audio",
+            format="wav",
+            sample_rate=22050,
+            duration=2.0
+        )
+
+        # Setup mock
+        implementation = MockImplementation()
+        implementation.mock_synthesize.return_value = expected_result
+
+        # Call method
+        result = implementation.synthesize(request)
+
+        # Verify call and result
+        implementation.mock_synthesize.assert_called_once_with(request)
+        assert result == expected_result
+
+    def test_synthesize_stream_method_contract_with_mock(self):
+        """Test the synthesize_stream method contract using a mock implementation."""
+
+        class MockImplementation(ISpeechSynthesisService):
+            def __init__(self):
+                self.mock_synthesize = Mock()
+                self.mock_synthesize_stream = Mock()
+
+            def synthesize(self, request):
+                return self.mock_synthesize(request)
+
+            def synthesize_stream(self, request):
+                return self.mock_synthesize_stream(request)
+
+        # Create test data
+        text_content = TextContent(text="Hello world", language="en")
+        voice_settings = VoiceSettings(voice_id="test_voice", speed=1.0, language="en")
+        request = SpeechSynthesisRequest(
+            text_content=text_content,
+            voice_settings=voice_settings
+        )
+        expected_chunks = [
+            AudioChunk(data=b"chunk1", format="wav", sample_rate=22050, chunk_index=0),
+            AudioChunk(data=b"chunk2", format="wav", sample_rate=22050, chunk_index=1, is_final=True)
+        ]
+
+        # Setup mock
+        implementation = MockImplementation()
+        implementation.mock_synthesize_stream.return_value = iter(expected_chunks)
+
+        # Call method
+        result = implementation.synthesize_stream(request)
+
+        # Verify call and result
+        implementation.mock_synthesize_stream.assert_called_once_with(request)
+        chunks = list(result)
+        assert chunks == expected_chunks
+
+    def test_interface_docstring_requirements(self):
+        """Test that the interface methods have proper documentation."""
+        synthesize_method = ISpeechSynthesisService.synthesize
+        stream_method = ISpeechSynthesisService.synthesize_stream
+
+        # Check synthesize method docstring
+        assert synthesize_method.__doc__ is not None
+        synthesize_doc = synthesize_method.__doc__
+        assert "Synthesize speech from text" in synthesize_doc
+        assert "Args:" in synthesize_doc
+        assert "Returns:" in synthesize_doc
+        assert "Raises:" in synthesize_doc
+        assert "SpeechSynthesisException" in synthesize_doc
+
+        # Check synthesize_stream method docstring
+        assert stream_method.__doc__ is not None
+        stream_doc = stream_method.__doc__
+        assert "Synthesize speech from text as a stream" in stream_doc
+        assert "Args:" in stream_doc
+        assert "Returns:" in stream_doc
+        assert "Iterator[AudioChunk]" in stream_doc
+        assert "Raises:" in stream_doc
+        assert "SpeechSynthesisException" in stream_doc
+
+    def test_interface_type_hints(self):
+        """Test that the interface uses proper type hints."""
+        synthesize_method = ISpeechSynthesisService.synthesize
+        stream_method = ISpeechSynthesisService.synthesize_stream
+
+        # Check synthesize method annotations
+        synthesize_annotations = getattr(synthesize_method, '__annotations__', {})
+        assert 'request' in synthesize_annotations
+        assert 'return' in synthesize_annotations
+        assert synthesize_annotations['request'] == "'SpeechSynthesisRequest'"
+        assert synthesize_annotations['return'] == "'AudioContent'"
+
+        # Check synthesize_stream method annotations
+        stream_annotations = getattr(stream_method, '__annotations__', {})
+        assert 'request' in stream_annotations
+        assert 'return' in stream_annotations
+        assert stream_annotations['request'] == "'SpeechSynthesisRequest'"
+        assert stream_annotations['return'] == "Iterator['AudioChunk']"
+
+    def test_multiple_implementations_possible(self):
+        """Test that multiple implementations of the interface are possible."""
+
+        class KokoroImplementation(ISpeechSynthesisService):
+            def synthesize(self, request):
+                return AudioContent(data=b"kokoro_audio", format="wav", sample_rate=22050, duration=1.0)
+
+            def synthesize_stream(self, request):
+                yield AudioChunk(data=b"kokoro_chunk", format="wav", sample_rate=22050, chunk_index=0, is_final=True)
+
+        class DiaImplementation(ISpeechSynthesisService):
+            def synthesize(self, request):
+                return AudioContent(data=b"dia_audio", format="wav", sample_rate=22050, duration=1.0)
+
+            def synthesize_stream(self, request):
+                yield AudioChunk(data=b"dia_chunk", format="wav", sample_rate=22050, chunk_index=0, is_final=True)
+
+        kokoro = KokoroImplementation()
+        dia = DiaImplementation()
+
+        assert isinstance(kokoro, ISpeechSynthesisService)
+        assert isinstance(dia, ISpeechSynthesisService)
+        assert type(kokoro) != type(dia)
+
+    def test_interface_methods_can_be_called_polymorphically(self):
+        """Test that interface methods can be called polymorphically."""
+
+        class TestImplementation(ISpeechSynthesisService):
+            def __init__(self, audio_data, chunk_data):
+                self.audio_data = audio_data
+                self.chunk_data = chunk_data
+
+            def synthesize(self, request):
+                return AudioContent(data=self.audio_data, format="wav", sample_rate=22050, duration=1.0)
+
+            def synthesize_stream(self, request):
+                yield AudioChunk(data=self.chunk_data, format="wav", sample_rate=22050, chunk_index=0, is_final=True)
+
+        # Create different implementations
+        implementations = [
+            TestImplementation(b"audio1", b"chunk1"),
+            TestImplementation(b"audio2", b"chunk2")
+        ]
+
+        # Test polymorphic usage
+        text_content = TextContent(text="test", language="en")
+        voice_settings = VoiceSettings(voice_id="test", speed=1.0, language="en")
+        request = SpeechSynthesisRequest(text_content=text_content, voice_settings=voice_settings)
+
+        # Test synthesize method
+        audio_results = []
+        for impl in implementations:
+            result = impl.synthesize(request)
+            audio_results.append(result.data)
+
+        assert audio_results == [b"audio1", b"audio2"]
+
+        # Test synthesize_stream method
+        chunk_results = []
+        for impl in implementations:
+            chunks = list(impl.synthesize_stream(request))
+            chunk_results.append(chunks[0].data)
+
+        assert chunk_results == [b"chunk1", b"chunk2"]
+
+    def test_interface_inheritance_chain(self):
+        """Test the inheritance chain of the interface."""
+        # Check that it inherits from ABC
+        assert ABC in ISpeechSynthesisService.__mro__
+
+        # Check that it's at the right position in MRO
+        mro = ISpeechSynthesisService.__mro__
+        assert mro[0] == ISpeechSynthesisService
+        assert ABC in mro
+
+    def test_stream_method_returns_iterator(self):
+        """Test that synthesize_stream returns an iterator."""
+
+        class StreamingImplementation(ISpeechSynthesisService):
+            def synthesize(self, request):
+                return AudioContent(data=b"audio", format="wav", sample_rate=22050, duration=1.0)
+
+            def synthesize_stream(self, request):
+                for i in range(3):
+                    yield AudioChunk(
+                        data=f"chunk{i}".encode(),
+                        format="wav",
+                        sample_rate=22050,
+                        chunk_index=i,
+                        is_final=(i == 2)
+                    )
+
+        impl = StreamingImplementation()
+        text_content = TextContent(text="test", language="en")
+        voice_settings = VoiceSettings(voice_id="test", speed=1.0, language="en")
+        request = SpeechSynthesisRequest(text_content=text_content, voice_settings=voice_settings)
+
+        # Get the iterator
+        stream = impl.synthesize_stream(request)
+
+        # Verify it's an iterator
+        assert hasattr(stream, '__iter__')
+        assert hasattr(stream, '__next__')
+
+        # Verify we can iterate through chunks
+        chunks = list(stream)
+        assert len(chunks) == 3
+
+        for i, chunk in enumerate(chunks):
+            assert chunk.data == f"chunk{i}".encode()
+            assert chunk.chunk_index == i
+            assert chunk.is_final == (i == 2)
+
+    def test_implementation_can_handle_different_formats(self):
+        """Test that implementations can handle different output formats."""
+
+        class MultiFormatImplementation(ISpeechSynthesisService):
+            def synthesize(self, request):
+                format_data = {
+                    "wav": b"wav_audio_data",
+                    "mp3": b"mp3_audio_data",
+                    "flac": b"flac_audio_data",
+                    "ogg": b"ogg_audio_data"
+                }
+
+                audio_data = format_data.get(request.output_format, b"default_audio_data")
+                return AudioContent(
+                    data=audio_data,
+                    format=request.output_format,
+                    sample_rate=request.effective_sample_rate,
+                    duration=1.0
+                )
+
+            def synthesize_stream(self, request):
+                yield AudioChunk(
+                    data=f"{request.output_format}_chunk".encode(),
+                    format=request.output_format,
+                    sample_rate=request.effective_sample_rate,
+                    chunk_index=0,
+                    is_final=True
+                )
+
+        impl = MultiFormatImplementation()
+        text_content = TextContent(text="test", language="en")
+        voice_settings = VoiceSettings(voice_id="test", speed=1.0, language="en")
+
+        # Test different formats
+        formats = ["wav", "mp3", "flac", "ogg"]
+
+        for fmt in formats:
+            request = SpeechSynthesisRequest(
+                text_content=text_content,
+                voice_settings=voice_settings,
+                output_format=fmt
+            )
+
+            # Test synthesize
+            audio = impl.synthesize(request)
+            assert audio.format == fmt
+            assert audio.data == f"{fmt}_audio_data".encode()
+
+            # Test synthesize_stream
+            chunks = list(impl.synthesize_stream(request))
+            assert len(chunks) == 1
+            assert chunks[0].format == fmt
+            assert chunks[0].data == f"{fmt}_chunk".encode()

tests/unit/domain/interfaces/test_translation.py

@@ -0,0 +1,303 @@
+"""Unit tests for ITranslationService interface contract."""
+
+import pytest
+from abc import ABC
+from unittest.mock import Mock
+from src.domain.interfaces.translation import ITranslationService
+from src.domain.models.translation_request import TranslationRequest
+from src.domain.models.text_content import TextContent
+
+
+class TestITranslationService:
+    """Test cases for ITranslationService interface contract."""
+
+    def test_interface_is_abstract(self):
+        """Test that ITranslationService is an abstract base class."""
+        assert issubclass(ITranslationService, ABC)
+
+        # Should not be able to instantiate directly
+        with pytest.raises(TypeError):
+            ITranslationService()  # type: ignore
+
+    def test_interface_has_required_method(self):
+        """Test that interface defines the required abstract method."""
+        # Check that the method exists and is abstract
+        assert hasattr(ITranslationService, 'translate')
+        assert getattr(ITranslationService.translate, '__isabstractmethod__', False)
+
+    def test_method_signature(self):
+        """Test that the method has the correct signature."""
+        import inspect
+
+        method = ITranslationService.translate
+        signature = inspect.signature(method)
+
+        # Check parameter names
+        params = list(signature.parameters.keys())
+        expected_params = ['self', 'request']
+
+        assert params == expected_params
+
+        # Check return annotation
+        assert signature.return_annotation == "'TextContent'"
+
+    def test_concrete_implementation_must_implement_method(self):
+        """Test that concrete implementations must implement the abstract method."""
+
+        class IncompleteImplementation(ITranslationService):
+            pass
+
+        # Should not be able to instantiate without implementing abstract method
+        with pytest.raises(TypeError, match="Can't instantiate abstract class"):
+            IncompleteImplementation()  # type: ignore
+
+    def test_concrete_implementation_with_method(self):
+        """Test that concrete implementation with method can be instantiated."""
+
+        class ConcreteImplementation(ITranslationService):
+            def translate(self, request):
+                return TextContent(text="translated text", language=request.target_language)
+
+        # Should be able to instantiate
+        implementation = ConcreteImplementation()
+        assert isinstance(implementation, ITranslationService)
+
+    def test_method_contract_with_mock(self):
+        """Test the method contract using a mock implementation."""
+
+        class MockImplementation(ITranslationService):
+            def __init__(self):
+                self.mock_method = Mock()
+
+            def translate(self, request):
+                return self.mock_method(request)
+
+        # Create test data
+        source_text = TextContent(text="Hello world", language="en")
+        request = TranslationRequest(
+            source_text=source_text,
+            target_language="es"
+        )
+        expected_result = TextContent(text="Hola mundo", language="es")
+
+        # Setup mock
+        implementation = MockImplementation()
+        implementation.mock_method.return_value = expected_result
+
+        # Call method
+        result = implementation.translate(request)
+
+        # Verify call and result
+        implementation.mock_method.assert_called_once_with(request)
+        assert result == expected_result
+
+    def test_interface_docstring_requirements(self):
+        """Test that the interface method has proper documentation."""
+        method = ITranslationService.translate
+
+        assert method.__doc__ is not None
+        docstring = method.__doc__
+
+        # Check that docstring contains key information
+        assert "Translate text from source language to target language" in docstring
+        assert "Args:" in docstring
+        assert "Returns:" in docstring
+        assert "Raises:" in docstring
+        assert "TranslationFailedException" in docstring
+
+    def test_interface_type_hints(self):
+        """Test that the interface uses proper type hints."""
+        method = ITranslationService.translate
+        annotations = getattr(method, '__annotations__', {})
+
+        assert 'request' in annotations
+        assert 'return' in annotations
+
+        # Check that type annotations are correct
+        assert annotations['request'] == "'TranslationRequest'"
+        assert annotations['return'] == "'TextContent'"
+
+    def test_multiple_implementations_possible(self):
+        """Test that multiple implementations of the interface are possible."""
+
+        class NLLBImplementation(ITranslationService):
+            def translate(self, request):
+                return TextContent(text="NLLB translation", language=request.target_language)
+
+        class GoogleImplementation(ITranslationService):
+            def translate(self, request):
+                return TextContent(text="Google translation", language=request.target_language)
+
+        nllb = NLLBImplementation()
+        google = GoogleImplementation()
+
+        assert isinstance(nllb, ITranslationService)
+        assert isinstance(google, ITranslationService)
+        assert type(nllb) != type(google)
+
+    def test_interface_method_can_be_called_polymorphically(self):
+        """Test that interface methods can be called polymorphically."""
+
+        class TestImplementation(ITranslationService):
+            def __init__(self, translation_prefix):
+                self.translation_prefix = translation_prefix
+
+            def translate(self, request):
+                translated_text = f"{self.translation_prefix}: {request.source_text.text}"
+                return TextContent(text=translated_text, language=request.target_language)
+
+        # Create different implementations
+        implementations = [
+            TestImplementation("Provider1"),
+            TestImplementation("Provider2")
+        ]
+
+        # Test polymorphic usage
+        source_text = TextContent(text="Hello", language="en")
+        request = TranslationRequest(source_text=source_text, target_language="es")
+
+        results = []
+        for impl in implementations:
+            # Can call the same method on different implementations
+            result = impl.translate(request)
+            results.append(result.text)
+
+        assert results == ["Provider1: Hello", "Provider2: Hello"]
+
+    def test_interface_inheritance_chain(self):
+        """Test the inheritance chain of the interface."""
+        # Check that it inherits from ABC
+        assert ABC in ITranslationService.__mro__
+
+        # Check that it's at the right position in MRO
+        mro = ITranslationService.__mro__
+        assert mro[0] == ITranslationService
+        assert ABC in mro
+
+    def test_method_parameter_validation_in_implementation(self):
+        """Test that implementations can validate parameters."""
+
+        class ValidatingImplementation(ITranslationService):
+            def translate(self, request):
+                if not isinstance(request, TranslationRequest):
+                    raise TypeError("request must be TranslationRequest")
+
+                # Validate that source and target languages are different
+                if request.effective_source_language == request.target_language:
+                    raise ValueError("Source and target languages cannot be the same")
+
+                return TextContent(
+                    text=f"Translated: {request.source_text.text}",
+                    language=request.target_language
+                )
+
+        impl = ValidatingImplementation()
+
+        # Valid call should work
+        source_text = TextContent(text="Hello", language="en")
+        request = TranslationRequest(source_text=source_text, target_language="es")
+        result = impl.translate(request)
+        assert result.text == "Translated: Hello"
+        assert result.language == "es"
+
+        # Invalid parameter type should raise error
+        with pytest.raises(TypeError, match="request must be TranslationRequest"):
+            impl.translate("not a request")  # type: ignore
+
+        # Same language should raise error
+        same_lang_text = TextContent(text="Hello", language="en")
+        same_lang_request = TranslationRequest(source_text=same_lang_text, target_language="en")
+        with pytest.raises(ValueError, match="Source and target languages cannot be the same"):
+            impl.translate(same_lang_request)
+
+    def test_implementation_can_handle_different_language_pairs(self):
+        """Test that implementations can handle different language pairs."""
+
+        class MultiLanguageImplementation(ITranslationService):
+            def __init__(self):
+                self.translations = {
+                    ("en", "es"): {"Hello": "Hola", "world": "mundo"},
+                    ("en", "fr"): {"Hello": "Bonjour", "world": "monde"},
+                    ("es", "en"): {"Hola": "Hello", "mundo": "world"},
+                    ("fr", "en"): {"Bonjour": "Hello", "monde": "world"}
+                }
+
+            def translate(self, request):
+                source_lang = request.effective_source_language
+                target_lang = request.target_language
+
+                translation_dict = self.translations.get((source_lang, target_lang), {})
+
+                # Simple word-by-word translation for testing
+                words = request.source_text.text.split()
+                translated_words = [translation_dict.get(word, word) for word in words]
+                translated_text = " ".join(translated_words)
+
+                return TextContent(text=translated_text, language=target_lang)
+
+        impl = MultiLanguageImplementation()
+
+        # Test different language pairs
+        test_cases = [
+            ("Hello world", "en", "es", "Hola mundo"),
+            ("Hello world", "en", "fr", "Bonjour monde"),
+            ("Hola mundo", "es", "en", "Hello world"),
+            ("Bonjour monde", "fr", "en", "Hello world")
+        ]
+
+        for text, source_lang, target_lang, expected in test_cases:
+            source_text = TextContent(text=text, language=source_lang)
+            request = TranslationRequest(
+                source_text=source_text,
+                target_language=target_lang,
+                source_language=source_lang
+            )
+
+            result = impl.translate(request)
+            assert result.text == expected
+            assert result.language == target_lang
+
+    def test_implementation_can_handle_auto_detect_source_language(self):
+        """Test that implementations can handle auto-detection of source language."""
+
+        class AutoDetectImplementation(ITranslationService):
+            def translate(self, request):
+                # Use the effective source language (from TextContent if not explicitly set)
+                source_lang = request.effective_source_language
+                target_lang = request.target_language
+
+                # Simple mock translation based on detected language
+                if source_lang == "en" and target_lang == "es":
+                    translated_text = f"ES: {request.source_text.text}"
+                elif source_lang == "es" and target_lang == "en":
+                    translated_text = f"EN: {request.source_text.text}"
+                else:
+                    translated_text = f"UNKNOWN: {request.source_text.text}"
+
+                return TextContent(text=translated_text, language=target_lang)
+
+        impl = AutoDetectImplementation()
+
+        # Test with explicit source language
+        source_text = TextContent(text="Hello", language="en")
+        explicit_request = TranslationRequest(
+            source_text=source_text,
+            target_language="es",
+            source_language="en"
+        )
+
+        result = impl.translate(explicit_request)
+        assert result.text == "ES: Hello"
+        assert result.language == "es"
+
+        # Test with auto-detected source language (None)
+        auto_request = TranslationRequest(
+            source_text=source_text,  # language="en" in TextContent
+            target_language="es"
+            # source_language=None (default)
+        )
+
+        result = impl.translate(auto_request)
+        assert result.text == "ES: Hello"  # Should use language from TextContent
+        assert result.language == "es"
+        assert auto_request.is_auto_detect_source is True

tests/unit/domain/models/test_audio_chunk.py

@@ -0,0 +1,322 @@
+"""Unit tests for AudioChunk value object."""
+
+import pytest
+from src.domain.models.audio_chunk import AudioChunk
+
+
+class TestAudioChunk:
+    """Test cases for AudioChunk value object."""
+
+    def test_valid_audio_chunk_creation(self):
+        """Test creating valid AudioChunk instance."""
+        chunk = AudioChunk(
+            data=b"fake_audio_chunk_data",
+            format="wav",
+            sample_rate=22050,
+            chunk_index=0,
+            is_final=False,
+            timestamp=1.5
+        )
+
+        assert chunk.data == b"fake_audio_chunk_data"
+        assert chunk.format == "wav"
+        assert chunk.sample_rate == 22050
+        assert chunk.chunk_index == 0
+        assert chunk.is_final is False
+        assert chunk.timestamp == 1.5
+        assert chunk.size_bytes == len(b"fake_audio_chunk_data")
+
+    def test_audio_chunk_with_defaults(self):
+        """Test creating AudioChunk with default values."""
+        chunk = AudioChunk(
+            data=b"fake_audio_chunk_data",
+            format="wav",
+            sample_rate=22050,
+            chunk_index=0
+        )
+
+        assert chunk.is_final is False
+        assert chunk.timestamp is None
+
+    def test_final_chunk_creation(self):
+        """Test creating final AudioChunk."""
+        chunk = AudioChunk(
+            data=b"final_chunk_data",
+            format="wav",
+            sample_rate=22050,
+            chunk_index=5,
+            is_final=True
+        )
+
+        assert chunk.is_final is True
+        assert chunk.chunk_index == 5
+
+    def test_non_bytes_data_raises_error(self):
+        """Test that non-bytes data raises TypeError."""
+        with pytest.raises(TypeError, match="Audio data must be bytes"):
+            AudioChunk(
+                data="not_bytes",  # type: ignore
+                format="wav",
+                sample_rate=22050,
+                chunk_index=0
+            )
+
+    def test_empty_data_raises_error(self):
+        """Test that empty data raises ValueError."""
+        with pytest.raises(ValueError, match="Audio data cannot be empty"):
+            AudioChunk(
+                data=b"",
+                format="wav",
+                sample_rate=22050,
+                chunk_index=0
+            )
+
+    def test_unsupported_format_raises_error(self):
+        """Test that unsupported format raises ValueError."""
+        with pytest.raises(ValueError, match="Unsupported audio format: xyz"):
+            AudioChunk(
+                data=b"fake_data",
+                format="xyz",
+                sample_rate=22050,
+                chunk_index=0
+            )
+
+    def test_supported_formats(self):
+        """Test all supported audio formats."""
+        supported_formats = ['wav', 'mp3', 'flac', 'ogg', 'raw']
+
+        for fmt in supported_formats:
+            chunk = AudioChunk(
+                data=b"fake_data",
+                format=fmt,
+                sample_rate=22050,
+                chunk_index=0
+            )
+            assert chunk.format == fmt
+
+    def test_non_integer_sample_rate_raises_error(self):
+        """Test that non-integer sample rate raises ValueError."""
+        with pytest.raises(ValueError, match="Sample rate must be a positive integer"):
+            AudioChunk(
+                data=b"fake_data",
+                format="wav",
+                sample_rate=22050.5,  # type: ignore
+                chunk_index=0
+            )
+
+    def test_negative_sample_rate_raises_error(self):
+        """Test that negative sample rate raises ValueError."""
+        with pytest.raises(ValueError, match="Sample rate must be a positive integer"):
+            AudioChunk(
+                data=b"fake_data",
+                format="wav",
+                sample_rate=-1,
+                chunk_index=0
+            )
+
+    def test_zero_sample_rate_raises_error(self):
+        """Test that zero sample rate raises ValueError."""
+        with pytest.raises(ValueError, match="Sample rate must be a positive integer"):
+            AudioChunk(
+                data=b"fake_data",
+                format="wav",
+                sample_rate=0,
+                chunk_index=0
+            )
+
+    def test_non_integer_chunk_index_raises_error(self):
+        """Test that non-integer chunk index raises ValueError."""
+        with pytest.raises(ValueError, match="Chunk index must be a non-negative integer"):
+            AudioChunk(
+                data=b"fake_data",
+                format="wav",
+                sample_rate=22050,
+                chunk_index=1.5  # type: ignore
+            )
+
+    def test_negative_chunk_index_raises_error(self):
+        """Test that negative chunk index raises ValueError."""
+        with pytest.raises(ValueError, match="Chunk index must be a non-negative integer"):
+            AudioChunk(
+                data=b"fake_data",
+                format="wav",
+                sample_rate=22050,
+                chunk_index=-1
+            )
+
+    def test_valid_chunk_index_zero(self):
+        """Test that chunk index of zero is valid."""
+        chunk = AudioChunk(
+            data=b"fake_data",
+            format="wav",
+            sample_rate=22050,
+            chunk_index=0
+        )
+        assert chunk.chunk_index == 0
+
+    def test_non_boolean_is_final_raises_error(self):
+        """Test that non-boolean is_final raises TypeError."""
+        with pytest.raises(TypeError, match="is_final must be a boolean"):
+            AudioChunk(
+                data=b"fake_data",
+                format="wav",
+                sample_rate=22050,
+                chunk_index=0,
+                is_final="true"  # type: ignore
+            )
+
+    def test_non_numeric_timestamp_raises_error(self):
+        """Test that non-numeric timestamp raises ValueError."""
+        with pytest.raises(ValueError, match="Timestamp must be a non-negative number"):
+            AudioChunk(
+                data=b"fake_data",
+                format="wav",
+                sample_rate=22050,
+                chunk_index=0,
+                timestamp="1.5"  # type: ignore
+            )
+
+    def test_negative_timestamp_raises_error(self):
+        """Test that negative timestamp raises ValueError."""
+        with pytest.raises(ValueError, match="Timestamp must be a non-negative number"):
+            AudioChunk(
+                data=b"fake_data",
+                format="wav",
+                sample_rate=22050,
+                chunk_index=0,
+                timestamp=-1.0
+            )
+
+    def test_valid_timestamp_zero(self):
+        """Test that timestamp of zero is valid."""
+        chunk = AudioChunk(
+            data=b"fake_data",
+            format="wav",
+            sample_rate=22050,
+            chunk_index=0,
+            timestamp=0.0
+        )
+        assert chunk.timestamp == 0.0
+
+    def test_valid_timestamp_values(self):
+        """Test valid timestamp values."""
+        valid_timestamps = [0.0, 1.5, 10, 100.123]
+
+        for timestamp in valid_timestamps:
+            chunk = AudioChunk(
+                data=b"fake_data",
+                format="wav",
+                sample_rate=22050,
+                chunk_index=0,
+                timestamp=timestamp
+            )
+            assert chunk.timestamp == timestamp
+
+    def test_size_bytes_property(self):
+        """Test size_bytes property returns correct value."""
+        test_data = b"test_audio_chunk_data_123"
+        chunk = AudioChunk(
+            data=test_data,
+            format="wav",
+            sample_rate=22050,
+            chunk_index=0
+        )
+
+        assert chunk.size_bytes == len(test_data)
+
+    def test_duration_estimate_property(self):
+        """Test duration_estimate property calculation."""
+        # Create chunk with known data size
+        test_data = b"x" * 44100  # 44100 bytes
+        chunk = AudioChunk(
+            data=test_data,
+            format="wav",
+            sample_rate=22050,  # 22050 samples per second
+            chunk_index=0
+        )
+
+        # Expected duration: 44100 bytes / (22050 samples/sec * 2 bytes/sample) = 1.0 second
+        expected_duration = 44100 / (22050 * 2)
+        assert abs(chunk.duration_estimate - expected_duration) < 0.01
+
+    def test_duration_estimate_with_zero_sample_rate(self):
+        """Test duration_estimate with edge case of zero calculation."""
+        # This shouldn't happen due to validation, but test the property logic
+        chunk = AudioChunk(
+            data=b"test_data",
+            format="wav",
+            sample_rate=22050,
+            chunk_index=0
+        )
+
+        # Should return a reasonable estimate
+        assert chunk.duration_estimate >= 0
+
+    def test_audio_chunk_is_immutable(self):
+        """Test that AudioChunk is immutable (frozen dataclass)."""
+        chunk = AudioChunk(
+            data=b"fake_data",
+            format="wav",
+            sample_rate=22050,
+            chunk_index=0
+        )
+
+        with pytest.raises(AttributeError):
+            chunk.format = "mp3"  # type: ignore
+
+    def test_chunk_sequence_ordering(self):
+        """Test that chunks can be ordered by chunk_index."""
+        chunks = [
+            AudioChunk(data=b"chunk2", format="wav", sample_rate=22050, chunk_index=2),
+            AudioChunk(data=b"chunk0", format="wav", sample_rate=22050, chunk_index=0),
+            AudioChunk(data=b"chunk1", format="wav", sample_rate=22050, chunk_index=1),
+        ]
+
+        # Sort by chunk_index
+        sorted_chunks = sorted(chunks, key=lambda c: c.chunk_index)
+
+        assert sorted_chunks[0].chunk_index == 0
+        assert sorted_chunks[1].chunk_index == 1
+        assert sorted_chunks[2].chunk_index == 2
+
+    def test_streaming_scenario(self):
+        """Test typical streaming scenario with multiple chunks."""
+        # First chunk
+        chunk1 = AudioChunk(
+            data=b"first_chunk_data",
+            format="wav",
+            sample_rate=22050,
+            chunk_index=0,
+            is_final=False,
+            timestamp=0.0
+        )
+
+        # Middle chunk
+        chunk2 = AudioChunk(
+            data=b"middle_chunk_data",
+            format="wav",
+            sample_rate=22050,
+            chunk_index=1,
+            is_final=False,
+            timestamp=1.0
+        )
+
+        # Final chunk
+        chunk3 = AudioChunk(
+            data=b"final_chunk_data",
+            format="wav",
+            sample_rate=22050,
+            chunk_index=2,
+            is_final=True,
+            timestamp=2.0
+        )
+
+        assert not chunk1.is_final
+        assert not chunk2.is_final
+        assert chunk3.is_final
+
+        # Verify ordering
+        chunks = [chunk1, chunk2, chunk3]
+        for i, chunk in enumerate(chunks):
+            assert chunk.chunk_index == i
+            assert chunk.timestamp == float(i)

tests/unit/domain/models/test_processing_result.py

@@ -0,0 +1,411 @@
+"""Unit tests for ProcessingResult value object."""
+
+import pytest
+from src.domain.models.processing_result import ProcessingResult
+from src.domain.models.text_content import TextContent
+from src.domain.models.audio_content import AudioContent
+
+
+class TestProcessingResult:
+    """Test cases for ProcessingResult value object."""
+
+    @pytest.fixture
+    def sample_text_content(self):
+        """Sample text content for testing."""
+        return TextContent(text="Hello, world!", language="en")
+
+    @pytest.fixture
+    def sample_translated_text(self):
+        """Sample translated text content for testing."""
+        return TextContent(text="Hola, mundo!", language="es")
+
+    @pytest.fixture
+    def sample_audio_content(self):
+        """Sample audio content for testing."""
+        return AudioContent(
+            data=b"fake_audio_data",
+            format="wav",
+            sample_rate=22050,
+            duration=5.0
+        )
+
+    def test_valid_successful_processing_result(self, sample_text_content, sample_translated_text, sample_audio_content):
+        """Test creating valid successful ProcessingResult."""
+        result = ProcessingResult(
+            success=True,
+            original_text=sample_text_content,
+            translated_text=sample_translated_text,
+            audio_output=sample_audio_content,
+            error_message=None,
+            processing_time=2.5
+        )
+
+        assert result.success is True
+        assert result.original_text == sample_text_content
+        assert result.translated_text == sample_translated_text
+        assert result.audio_output == sample_audio_content
+        assert result.error_message is None
+        assert result.processing_time == 2.5
+        assert result.has_translation is True
+        assert result.has_audio_output is True
+        assert result.is_complete_pipeline is True
+
+    def test_valid_failed_processing_result(self):
+        """Test creating valid failed ProcessingResult."""
+        result = ProcessingResult(
+            success=False,
+            original_text=None,
+            translated_text=None,
+            audio_output=None,
+            error_message="Processing failed",
+            processing_time=1.0
+        )
+
+        assert result.success is False
+        assert result.original_text is None
+        assert result.translated_text is None
+        assert result.audio_output is None
+        assert result.error_message == "Processing failed"
+        assert result.processing_time == 1.0
+        assert result.has_translation is False
+        assert result.has_audio_output is False
+        assert result.is_complete_pipeline is False
+
+    def test_non_boolean_success_raises_error(self, sample_text_content):
+        """Test that non-boolean success raises TypeError."""
+        with pytest.raises(TypeError, match="Success must be a boolean"):
+            ProcessingResult(
+                success="true",  # type: ignore
+                original_text=sample_text_content,
+                translated_text=None,
+                audio_output=None,
+                error_message=None,
+                processing_time=1.0
+            )
+
+    def test_invalid_original_text_type_raises_error(self):
+        """Test that invalid original text type raises TypeError."""
+        with pytest.raises(TypeError, match="Original text must be a TextContent instance or None"):
+            ProcessingResult(
+                success=True,
+                original_text="not a TextContent",  # type: ignore
+                translated_text=None,
+                audio_output=None,
+                error_message=None,
+                processing_time=1.0
+            )
+
+    def test_invalid_translated_text_type_raises_error(self, sample_text_content):
+        """Test that invalid translated text type raises TypeError."""
+        with pytest.raises(TypeError, match="Translated text must be a TextContent instance or None"):
+            ProcessingResult(
+                success=True,
+                original_text=sample_text_content,
+                translated_text="not a TextContent",  # type: ignore
+                audio_output=None,
+                error_message=None,
+                processing_time=1.0
+            )
+
+    def test_invalid_audio_output_type_raises_error(self, sample_text_content):
+        """Test that invalid audio output type raises TypeError."""
+        with pytest.raises(TypeError, match="Audio output must be an AudioContent instance or None"):
+            ProcessingResult(
+                success=True,
+                original_text=sample_text_content,
+                translated_text=None,
+                audio_output="not an AudioContent",  # type: ignore
+                error_message=None,
+                processing_time=1.0
+            )
+
+    def test_invalid_error_message_type_raises_error(self, sample_text_content):
+        """Test that invalid error message type raises TypeError."""
+        with pytest.raises(TypeError, match="Error message must be a string or None"):
+            ProcessingResult(
+                success=True,
+                original_text=sample_text_content,
+                translated_text=None,
+                audio_output=None,
+                error_message=123,  # type: ignore
+                processing_time=1.0
+            )
+
+    def test_non_numeric_processing_time_raises_error(self, sample_text_content):
+        """Test that non-numeric processing time raises TypeError."""
+        with pytest.raises(TypeError, match="Processing time must be a number"):
+            ProcessingResult(
+                success=True,
+                original_text=sample_text_content,
+                translated_text=None,
+                audio_output=None,
+                error_message=None,
+                processing_time="1.0"  # type: ignore
+            )
+
+    def test_negative_processing_time_raises_error(self, sample_text_content):
+        """Test that negative processing time raises ValueError."""
+        with pytest.raises(ValueError, match="Processing time cannot be negative"):
+            ProcessingResult(
+                success=True,
+                original_text=sample_text_content,
+                translated_text=None,
+                audio_output=None,
+                error_message=None,
+                processing_time=-1.0
+            )
+
+    def test_successful_result_with_error_message_raises_error(self, sample_text_content):
+        """Test that successful result with error message raises ValueError."""
+        with pytest.raises(ValueError, match="Successful result cannot have an error message"):
+            ProcessingResult(
+                success=True,
+                original_text=sample_text_content,
+                translated_text=None,
+                audio_output=None,
+                error_message="This should not be here",
+                processing_time=1.0
+            )
+
+    def test_successful_result_without_original_text_raises_error(self):
+        """Test that successful result without original text raises ValueError."""
+        with pytest.raises(ValueError, match="Successful result must have original text"):
+            ProcessingResult(
+                success=True,
+                original_text=None,
+                translated_text=None,
+                audio_output=None,
+                error_message=None,
+                processing_time=1.0
+            )
+
+    def test_failed_result_without_error_message_raises_error(self):
+        """Test that failed result without error message raises ValueError."""
+        with pytest.raises(ValueError, match="Failed result must have a non-empty error message"):
+            ProcessingResult(
+                success=False,
+                original_text=None,
+                translated_text=None,
+                audio_output=None,
+                error_message=None,
+                processing_time=1.0
+            )
+
+    def test_failed_result_with_empty_error_message_raises_error(self):
+        """Test that failed result with empty error message raises ValueError."""
+        with pytest.raises(ValueError, match="Failed result must have a non-empty error message"):
+            ProcessingResult(
+                success=False,
+                original_text=None,
+                translated_text=None,
+                audio_output=None,
+                error_message="",
+                processing_time=1.0
+            )
+
+    def test_failed_result_with_whitespace_error_message_raises_error(self):
+        """Test that failed result with whitespace-only error message raises ValueError."""
+        with pytest.raises(ValueError, match="Failed result must have a non-empty error message"):
+            ProcessingResult(
+                success=False,
+                original_text=None,
+                translated_text=None,
+                audio_output=None,
+                error_message="   ",
+                processing_time=1.0
+            )
+
+    def test_has_translation_property(self, sample_text_content, sample_translated_text):
+        """Test has_translation property."""
+        # With translation
+        result_with_translation = ProcessingResult(
+            success=True,
+            original_text=sample_text_content,
+            translated_text=sample_translated_text,
+            audio_output=None,
+            error_message=None,
+            processing_time=1.0
+        )
+        assert result_with_translation.has_translation is True
+
+        # Without translation
+        result_without_translation = ProcessingResult(
+            success=True,
+            original_text=sample_text_content,
+            translated_text=None,
+            audio_output=None,
+            error_message=None,
+            processing_time=1.0
+        )
+        assert result_without_translation.has_translation is False
+
+    def test_has_audio_output_property(self, sample_text_content, sample_audio_content):
+        """Test has_audio_output property."""
+        # With audio output
+        result_with_audio = ProcessingResult(
+            success=True,
+            original_text=sample_text_content,
+            translated_text=None,
+            audio_output=sample_audio_content,
+            error_message=None,
+            processing_time=1.0
+        )
+        assert result_with_audio.has_audio_output is True
+
+        # Without audio output
+        result_without_audio = ProcessingResult(
+            success=True,
+            original_text=sample_text_content,
+            translated_text=None,
+            audio_output=None,
+            error_message=None,
+            processing_time=1.0
+        )
+        assert result_without_audio.has_audio_output is False
+
+    def test_is_complete_pipeline_property(self, sample_text_content, sample_translated_text, sample_audio_content):
+        """Test is_complete_pipeline property."""
+        # Complete pipeline
+        complete_result = ProcessingResult(
+            success=True,
+            original_text=sample_text_content,
+            translated_text=sample_translated_text,
+            audio_output=sample_audio_content,
+            error_message=None,
+            processing_time=1.0
+        )
+        assert complete_result.is_complete_pipeline is True
+
+        # Incomplete pipeline (missing translation)
+        incomplete_result = ProcessingResult(
+            success=True,
+            original_text=sample_text_content,
+            translated_text=None,
+            audio_output=sample_audio_content,
+            error_message=None,
+            processing_time=1.0
+        )
+        assert incomplete_result.is_complete_pipeline is False
+
+        # Failed result
+        failed_result = ProcessingResult(
+            success=False,
+            original_text=None,
+            translated_text=None,
+            audio_output=None,
+            error_message="Failed",
+            processing_time=1.0
+        )
+        assert failed_result.is_complete_pipeline is False
+
+    def test_success_result_class_method(self, sample_text_content, sample_translated_text, sample_audio_content):
+        """Test success_result class method."""
+        result = ProcessingResult.success_result(
+            original_text=sample_text_content,
+            translated_text=sample_translated_text,
+            audio_output=sample_audio_content,
+            processing_time=2.5
+        )
+
+        assert result.success is True
+        assert result.original_text == sample_text_content
+        assert result.translated_text == sample_translated_text
+        assert result.audio_output == sample_audio_content
+        assert result.error_message is None
+        assert result.processing_time == 2.5
+
+    def test_success_result_with_minimal_parameters(self, sample_text_content):
+        """Test success_result class method with minimal parameters."""
+        result = ProcessingResult.success_result(
+            original_text=sample_text_content
+        )
+
+        assert result.success is True
+        assert result.original_text == sample_text_content
+        assert result.translated_text is None
+        assert result.audio_output is None
+        assert result.error_message is None
+        assert result.processing_time == 0.0
+
+    def test_failure_result_class_method(self, sample_text_content):
+        """Test failure_result class method."""
+        result = ProcessingResult.failure_result(
+            error_message="Something went wrong",
+            processing_time=1.5,
+            original_text=sample_text_content
+        )
+
+        assert result.success is False
+        assert result.original_text == sample_text_content
+        assert result.translated_text is None
+        assert result.audio_output is None
+        assert result.error_message == "Something went wrong"
+        assert result.processing_time == 1.5
+
+    def test_failure_result_with_minimal_parameters(self):
+        """Test failure_result class method with minimal parameters."""
+        result = ProcessingResult.failure_result(
+            error_message="Failed"
+        )
+
+        assert result.success is False
+        assert result.original_text is None
+        assert result.translated_text is None
+        assert result.audio_output is None
+        assert result.error_message == "Failed"
+        assert result.processing_time == 0.0
+
+    def test_processing_result_is_immutable(self, sample_text_content):
+        """Test that ProcessingResult is immutable (frozen dataclass)."""
+        result = ProcessingResult(
+            success=True,
+            original_text=sample_text_content,
+            translated_text=None,
+            audio_output=None,
+            error_message=None,
+            processing_time=1.0
+        )
+
+        with pytest.raises(AttributeError):
+            result.success = False  # type: ignore
+
+    def test_zero_processing_time_valid(self, sample_text_content):
+        """Test that zero processing time is valid."""
+        result = ProcessingResult(
+            success=True,
+            original_text=sample_text_content,
+            translated_text=None,
+            audio_output=None,
+            error_message=None,
+            processing_time=0.0
+        )
+
+        assert result.processing_time == 0.0
+
+    def test_partial_success_scenarios(self, sample_text_content, sample_translated_text):
+        """Test various partial success scenarios."""
+        # Only STT completed
+        stt_only = ProcessingResult(
+            success=True,
+            original_text=sample_text_content,
+            translated_text=None,
+            audio_output=None,
+            error_message=None,
+            processing_time=1.0
+        )
+        assert stt_only.has_translation is False
+        assert stt_only.has_audio_output is False
+        assert stt_only.is_complete_pipeline is False
+
+        # STT + Translation completed
+        stt_translation = ProcessingResult(
+            success=True,
+            original_text=sample_text_content,
+            translated_text=sample_translated_text,
+            audio_output=None,
+            error_message=None,
+            processing_time=1.5
+        )
+        assert stt_translation.has_translation is True
+        assert stt_translation.has_audio_output is False
+        assert stt_translation.is_complete_pipeline is False

tests/unit/domain/models/test_speech_synthesis_request.py

@@ -8,342 +8,316 @@ from src.domain.models.voice_settings import VoiceSettings
 
 class TestSpeechSynthesisRequest:
     """Test cases for SpeechSynthesisRequest value object."""
-    
-    def test_valid_speech_synthesis_request_creation(self):
+
+    @pytest.fixture
+    def sample_text_content(self):
+        """Sample text content for testing."""
+        return TextContent(
+            text="Hello, world!",
+            language="en"
+        )
+
+    @pytest.fixture
+    def sample_voice_settings(self):
+        """Sample voice settings for testing."""
+        return VoiceSettings(
+            voice_id="en_male_001",
+            speed=1.0,
+            language="en"
+        )
+
+    def test_valid_speech_synthesis_request_creation(self, sample_text_content, sample_voice_settings):
         """Test creating valid SpeechSynthesisRequest instance."""
-        text = TextContent(text="Hello, world!", language="en")
-        voice_settings = VoiceSettings(voice_id="en_male_001", speed=1.2, language="en")
-        
         request = SpeechSynthesisRequest(
-            text=text,
-            voice_settings=voice_settings,
+            text_content=sample_text_content,
+            voice_settings=sample_voice_settings,
             output_format="wav",
-            sample_rate=44100
+            sample_rate=22050
         )
-        
-        assert request.text == text
-        assert request.voice_settings == voice_settings
+
+        assert request.text_content == sample_text_content
+        assert request.voice_settings == sample_voice_settings
         assert request.output_format == "wav"
-        assert request.sample_rate == 44100
-        assert request.effective_sample_rate == 44100
-    
-    def test_speech_synthesis_request_with_defaults(self):
+        assert request.sample_rate == 22050
+        assert request.effective_sample_rate == 22050
+
+    def test_speech_synthesis_request_with_defaults(self, sample_text_content, sample_voice_settings):
         """Test creating SpeechSynthesisRequest with default values."""
-        text = TextContent(text="Hello, world!", language="en")
-        voice_settings = VoiceSettings(voice_id="en_male_001", speed=1.0, language="en")
-        
         request = SpeechSynthesisRequest(
-            text=text,
-            voice_settings=voice_settings
+            text_content=sample_text_content,
+            voice_settings=sample_voice_settings
         )
-        
+
         assert request.output_format == "wav"
         assert request.sample_rate is None
         assert request.effective_sample_rate == 22050  # Default
-    
-    def test_non_text_content_raises_error(self):
-        """Test that non-TextContent text raises TypeError."""
-        voice_settings = VoiceSettings(voice_id="en_male_001", speed=1.0, language="en")
-        
+
+    def test_non_text_content_raises_error(self, sample_voice_settings):
+        """Test that non-TextContent raises TypeError."""
         with pytest.raises(TypeError, match="Text must be a TextContent instance"):
             SpeechSynthesisRequest(
-                text="Hello, world!",  # type: ignore
-                voice_settings=voice_settings
+                text_content="not a TextContent",  # type: ignore
+                voice_settings=sample_voice_settings
             )
-    
-    def test_non_voice_settings_raises_error(self):
-        """Test that non-VoiceSettings voice_settings raises TypeError."""
-        text = TextContent(text="Hello, world!", language="en")
-        
+
+    def test_non_voice_settings_raises_error(self, sample_text_content):
+        """Test that non-VoiceSettings raises TypeError."""
         with pytest.raises(TypeError, match="Voice settings must be a VoiceSettings instance"):
             SpeechSynthesisRequest(
-                text=text,
-                voice_settings={"voice_id": "en_male_001", "speed": 1.0}  # type: ignore
+                text_content=sample_text_content,
+                voice_settings="not voice settings"  # type: ignore
             )
-    
-    def test_non_string_output_format_raises_error(self):
-        """Test that non-string output_format raises TypeError."""
-        text = TextContent(text="Hello, world!", language="en")
-        voice_settings = VoiceSettings(voice_id="en_male_001", speed=1.0, language="en")
-        
+
+    def test_non_string_output_format_raises_error(self, sample_text_content, sample_voice_settings):
+        """Test that non-string output format raises TypeError."""
         with pytest.raises(TypeError, match="Output format must be a string"):
             SpeechSynthesisRequest(
-                text=text,
-                voice_settings=voice_settings,
+                text_content=sample_text_content,
+                voice_settings=sample_voice_settings,
                 output_format=123  # type: ignore
             )
-    
-    def test_unsupported_output_format_raises_error(self):
-        """Test that unsupported output_format raises ValueError."""
-        text = TextContent(text="Hello, world!", language="en")
-        voice_settings = VoiceSettings(voice_id="en_male_001", speed=1.0, language="en")
-        
+
+    def test_unsupported_output_format_raises_error(self, sample_text_content, sample_voice_settings):
+        """Test that unsupported output format raises ValueError."""
         with pytest.raises(ValueError, match="Unsupported output format: xyz"):
             SpeechSynthesisRequest(
-                text=text,
-                voice_settings=voice_settings,
+                text_content=sample_text_content,
+                voice_settings=sample_voice_settings,
                 output_format="xyz"
             )
-    
-    def test_supported_output_formats(self):
+
+    def test_supported_output_formats(self, sample_text_content, sample_voice_settings):
         """Test all supported output formats."""
-        text = TextContent(text="Hello, world!", language="en")
-        voice_settings = VoiceSettings(voice_id="en_male_001", speed=1.0, language="en")
         supported_formats = ['wav', 'mp3', 'flac', 'ogg']
-        
+
         for fmt in supported_formats:
             request = SpeechSynthesisRequest(
-                text=text,
-                voice_settings=voice_settings,
+                text_content=sample_text_content,
+                voice_settings=sample_voice_settings,
                 output_format=fmt
             )
             assert request.output_format == fmt
-    
-    def test_non_integer_sample_rate_raises_error(self):
-        """Test that non-integer sample_rate raises TypeError."""
-        text = TextContent(text="Hello, world!", language="en")
-        voice_settings = VoiceSettings(voice_id="en_male_001", speed=1.0, language="en")
-        
+
+    def test_non_integer_sample_rate_raises_error(self, sample_text_content, sample_voice_settings):
+        """Test that non-integer sample rate raises TypeError."""
         with pytest.raises(TypeError, match="Sample rate must be an integer"):
             SpeechSynthesisRequest(
-                text=text,
-                voice_settings=voice_settings,
-                sample_rate=44100.5  # type: ignore
+                text_content=sample_text_content,
+                voice_settings=sample_voice_settings,
+                sample_rate=22050.5  # type: ignore
             )
-    
-    def test_negative_sample_rate_raises_error(self):
-        """Test that negative sample_rate raises ValueError."""
-        text = TextContent(text="Hello, world!", language="en")
-        voice_settings = VoiceSettings(voice_id="en_male_001", speed=1.0, language="en")
-        
+
+    def test_negative_sample_rate_raises_error(self, sample_text_content, sample_voice_settings):
+        """Test that negative sample rate raises ValueError."""
         with pytest.raises(ValueError, match="Sample rate must be positive"):
             SpeechSynthesisRequest(
-                text=text,
-                voice_settings=voice_settings,
+                text_content=sample_text_content,
+                voice_settings=sample_voice_settings,
                 sample_rate=-1
             )
-    
-    def test_zero_sample_rate_raises_error(self):
-        """Test that zero sample_rate raises ValueError."""
-        text = TextContent(text="Hello, world!", language="en")
-        voice_settings = VoiceSettings(voice_id="en_male_001", speed=1.0, language="en")
-        
+
+    def test_zero_sample_rate_raises_error(self, sample_text_content, sample_voice_settings):
+        """Test that zero sample rate raises ValueError."""
         with pytest.raises(ValueError, match="Sample rate must be positive"):
             SpeechSynthesisRequest(
-                text=text,
-                voice_settings=voice_settings,
+                text_content=sample_text_content,
+                voice_settings=sample_voice_settings,
                 sample_rate=0
             )
-    
-    def test_sample_rate_too_low_raises_error(self):
+
+    def test_sample_rate_too_low_raises_error(self, sample_text_content, sample_voice_settings):
         """Test that sample rate below 8000 raises ValueError."""
-        text = TextContent(text="Hello, world!", language="en")
-        voice_settings = VoiceSettings(voice_id="en_male_001", speed=1.0, language="en")
-        
         with pytest.raises(ValueError, match="Sample rate must be between 8000 and 192000 Hz"):
             SpeechSynthesisRequest(
-                text=text,
-                voice_settings=voice_settings,
+                text_content=sample_text_content,
+                voice_settings=sample_voice_settings,
                 sample_rate=7999
             )
-    
-    def test_sample_rate_too_high_raises_error(self):
+
+    def test_sample_rate_too_high_raises_error(self, sample_text_content, sample_voice_settings):
         """Test that sample rate above 192000 raises ValueError."""
-        text = TextContent(text="Hello, world!", language="en")
-        voice_settings = VoiceSettings(voice_id="en_male_001", speed=1.0, language="en")
-        
         with pytest.raises(ValueError, match="Sample rate must be between 8000 and 192000 Hz"):
             SpeechSynthesisRequest(
-                text=text,
-                voice_settings=voice_settings,
+                text_content=sample_text_content,
+                voice_settings=sample_voice_settings,
                 sample_rate=192001
             )
-    
-    def test_valid_sample_rate_boundaries(self):
+
+    def test_valid_sample_rate_boundaries(self, sample_text_content, sample_voice_settings):
         """Test valid sample rate boundaries."""
-        text = TextContent(text="Hello, world!", language="en")
-        voice_settings = VoiceSettings(voice_id="en_male_001", speed=1.0, language="en")
-        
         # Test minimum valid sample rate
         request_min = SpeechSynthesisRequest(
-            text=text,
-            voice_settings=voice_settings,
+            text_content=sample_text_content,
+            voice_settings=sample_voice_settings,
             sample_rate=8000
         )
         assert request_min.sample_rate == 8000
-        
+
         # Test maximum valid sample rate
         request_max = SpeechSynthesisRequest(
-            text=text,
-            voice_settings=voice_settings,
+            text_content=sample_text_content,
+            voice_settings=sample_voice_settings,
             sample_rate=192000
         )
         assert request_max.sample_rate == 192000
-    
-    def test_mismatched_languages_raises_error(self):
-        """Test that mismatched text and voice languages raise ValueError."""
-        text = TextContent(text="Hello, world!", language="en")
-        voice_settings = VoiceSettings(voice_id="fr_male_001", speed=1.0, language="fr")
-        
-        with pytest.raises(ValueError, match="Text language \\(en\\) must match voice language \\(fr\\)"):
+
+    def test_language_mismatch_raises_error(self, sample_voice_settings):
+        """Test that language mismatch between text and voice raises ValueError."""
+        text_content = TextContent(text="Hola mundo", language="es")
+
+        with pytest.raises(ValueError, match="Text language \\(es\\) must match voice language \\(en\\)"):
             SpeechSynthesisRequest(
-                text=text,
-                voice_settings=voice_settings
+                text_content=text_content,
+                voice_settings=sample_voice_settings  # language="en"
             )
-    
+
     def test_matching_languages_success(self):
-        """Test that matching text and voice languages work correctly."""
-        text = TextContent(text="Bonjour le monde!", language="fr")
-        voice_settings = VoiceSettings(voice_id="fr_male_001", speed=1.0, language="fr")
-        
+        """Test that matching languages between text and voice works."""
+        text_content = TextContent(text="Hola mundo", language="es")
+        voice_settings = VoiceSettings(voice_id="es_female_001", speed=1.0, language="es")
+
         request = SpeechSynthesisRequest(
-            text=text,
+            text_content=text_content,
             voice_settings=voice_settings
         )
-        
-        assert request.text.language == "fr"
-        assert request.voice_settings.language == "fr"
-    
-    def test_estimated_duration_seconds_property(self):
+
+        assert request.text_content.language == request.voice_settings.language
+
+    def test_estimated_duration_seconds_property(self, sample_text_content, sample_voice_settings):
         """Test estimated_duration_seconds property calculation."""
-        text = TextContent(text="Hello world test", language="en")  # 3 words
-        voice_settings = VoiceSettings(voice_id="en_male_001", speed=1.0, language="en")
-        
         request = SpeechSynthesisRequest(
-            text=text,
-            voice_settings=voice_settings
+            text_content=sample_text_content,
+            voice_settings=sample_voice_settings
+        )
+
+        # Should be based on word count and speed
+        expected_duration = (sample_text_content.word_count / (175 / sample_voice_settings.speed)) * 60
+        assert abs(request.estimated_duration_seconds - expected_duration) < 0.01
+
+    def test_estimated_duration_with_different_speed(self, sample_text_content):
+        """Test estimated duration with different speech speed."""
+        fast_voice = VoiceSettings(voice_id="test", speed=2.0, language="en")
+        slow_voice = VoiceSettings(voice_id="test", speed=0.5, language="en")
+
+        fast_request = SpeechSynthesisRequest(
+            text_content=sample_text_content,
+            voice_settings=fast_voice
+        )
+
+        slow_request = SpeechSynthesisRequest(
+            text_content=sample_text_content,
+            voice_settings=slow_voice
         )
-        
-        # 3 words at 175 words per minute = 3/175 * 60 ≈ 1.03 seconds
-        estimated = request.estimated_duration_seconds
-        assert 1.0 <= estimated <= 1.1
-    
-    def test_estimated_duration_with_speed_adjustment(self):
-        """Test estimated duration with different speed settings."""
-        text = TextContent(text="Hello world test", language="en")  # 3 words
-        voice_settings_slow = VoiceSettings(voice_id="en_male_001", speed=0.5, language="en")
-        voice_settings_fast = VoiceSettings(voice_id="en_male_001", speed=2.0, language="en")
-        
-        request_slow = SpeechSynthesisRequest(text=text, voice_settings=voice_settings_slow)
-        request_fast = SpeechSynthesisRequest(text=text, voice_settings=voice_settings_fast)
-        
-        # Slower speed should result in longer duration
-        assert request_slow.estimated_duration_seconds > request_fast.estimated_duration_seconds
-    
-    def test_is_long_text_property(self):
+
+        # Faster speed should result in shorter duration
+        assert fast_request.estimated_duration_seconds < slow_request.estimated_duration_seconds
+
+    def test_is_long_text_property(self, sample_voice_settings):
         """Test is_long_text property."""
-        short_text = TextContent(text="Hello world", language="en")
-        long_text = TextContent(text="a" * 5001, language="en")
-        voice_settings = VoiceSettings(voice_id="en_male_001", speed=1.0, language="en")
-        
-        request_short = SpeechSynthesisRequest(text=short_text, voice_settings=voice_settings)
-        request_long = SpeechSynthesisRequest(text=long_text, voice_settings=voice_settings)
-        
-        assert request_short.is_long_text is False
-        assert request_long.is_long_text is True
-    
-    def test_effective_sample_rate_property(self):
-        """Test effective_sample_rate property."""
-        text = TextContent(text="Hello, world!", language="en")
-        voice_settings = VoiceSettings(voice_id="en_male_001", speed=1.0, language="en")
-        
-        # With explicit sample rate
-        request_explicit = SpeechSynthesisRequest(
-            text=text,
-            voice_settings=voice_settings,
-            sample_rate=44100
+        # Short text
+        short_text = TextContent(text="Hello", language="en")
+        short_request = SpeechSynthesisRequest(
+            text_content=short_text,
+            voice_settings=sample_voice_settings
         )
-        assert request_explicit.effective_sample_rate == 44100
-        
-        # Without explicit sample rate (default)
-        request_default = SpeechSynthesisRequest(
-            text=text,
-            voice_settings=voice_settings
+        assert short_request.is_long_text is False
+
+        # Long text (over 5000 characters)
+        long_text = TextContent(text="a" * 5001, language="en")
+        long_request = SpeechSynthesisRequest(
+            text_content=long_text,
+            voice_settings=sample_voice_settings
         )
-        assert request_default.effective_sample_rate == 22050
-    
-    def test_with_output_format_method(self):
+        assert long_request.is_long_text is True
+
+    def test_with_output_format_method(self, sample_text_content, sample_voice_settings):
         """Test with_output_format method creates new instance."""
-        text = TextContent(text="Hello, world!", language="en")
-        voice_settings = VoiceSettings(voice_id="en_male_001", speed=1.0, language="en")
-        
         original = SpeechSynthesisRequest(
-            text=text,
-            voice_settings=voice_settings,
+            text_content=sample_text_content,
+            voice_settings=sample_voice_settings,
             output_format="wav",
-            sample_rate=44100
+            sample_rate=22050
         )
-        
+
         new_request = original.with_output_format("mp3")
-        
+
         assert new_request.output_format == "mp3"
-        assert new_request.text == original.text
+        assert new_request.text_content == original.text_content
         assert new_request.voice_settings == original.voice_settings
         assert new_request.sample_rate == original.sample_rate
         assert new_request is not original  # Different instances
-    
-    def test_with_sample_rate_method(self):
+
+    def test_with_sample_rate_method(self, sample_text_content, sample_voice_settings):
         """Test with_sample_rate method creates new instance."""
-        text = TextContent(text="Hello, world!", language="en")
-        voice_settings = VoiceSettings(voice_id="en_male_001", speed=1.0, language="en")
-        
         original = SpeechSynthesisRequest(
-            text=text,
-            voice_settings=voice_settings,
-            sample_rate=44100
+            text_content=sample_text_content,
+            voice_settings=sample_voice_settings,
+            sample_rate=22050
         )
-        
-        new_request = original.with_sample_rate(22050)
-        
-        assert new_request.sample_rate == 22050
-        assert new_request.text == original.text
+
+        new_request = original.with_sample_rate(44100)
+
+        assert new_request.sample_rate == 44100
+        assert new_request.text_content == original.text_content
         assert new_request.voice_settings == original.voice_settings
         assert new_request.output_format == original.output_format
         assert new_request is not original  # Different instances
-    
-    def test_with_sample_rate_none(self):
+
+    def test_with_sample_rate_none(self, sample_text_content, sample_voice_settings):
         """Test with_sample_rate method with None value."""
-        text = TextContent(text="Hello, world!", language="en")
-        voice_settings = VoiceSettings(voice_id="en_male_001", speed=1.0, language="en")
-        
         original = SpeechSynthesisRequest(
-            text=text,
-            voice_settings=voice_settings,
-            sample_rate=44100
+            text_content=sample_text_content,
+            voice_settings=sample_voice_settings,
+            sample_rate=22050
         )
-        
+
         new_request = original.with_sample_rate(None)
         assert new_request.sample_rate is None
-        assert new_request.effective_sample_rate == 22050
-    
-    def test_with_voice_settings_method(self):
+        assert new_request.effective_sample_rate == 22050  # Default
+
+    def test_with_voice_settings_method(self, sample_text_content, sample_voice_settings):
         """Test with_voice_settings method creates new instance."""
-        text = TextContent(text="Hello, world!", language="en")
-        original_voice = VoiceSettings(voice_id="en_male_001", speed=1.0, language="en")
-        new_voice = VoiceSettings(voice_id="en_female_001", speed=1.5, language="en")
-        
+        new_voice_settings = VoiceSettings(voice_id="en_female_001", speed=1.5, language="en")
+
         original = SpeechSynthesisRequest(
-            text=text,
-            voice_settings=original_voice
+            text_content=sample_text_content,
+            voice_settings=sample_voice_settings
         )
-        
-        new_request = original.with_voice_settings(new_voice)
-        
-        assert new_request.voice_settings == new_voice
-        assert new_request.text == original.text
+
+        new_request = original.with_voice_settings(new_voice_settings)
+
+        assert new_request.voice_settings == new_voice_settings
+        assert new_request.text_content == original.text_content
         assert new_request.output_format == original.output_format
         assert new_request.sample_rate == original.sample_rate
         assert new_request is not original  # Different instances
-    
-    def test_speech_synthesis_request_is_immutable(self):
+
+    def test_speech_synthesis_request_is_immutable(self, sample_text_content, sample_voice_settings):
         """Test that SpeechSynthesisRequest is immutable (frozen dataclass)."""
-        text = TextContent(text="Hello, world!", language="en")
-        voice_settings = VoiceSettings(voice_id="en_male_001", speed=1.0, language="en")
-        
         request = SpeechSynthesisRequest(
-            text=text,
-            voice_settings=voice_settings
+            text_content=sample_text_content,
+            voice_settings=sample_voice_settings
         )
-        
+
         with pytest.raises(AttributeError):
-            request.output_format = "mp3"  # type: ignore
+            request.output_format = "mp3"  # type: ignore
+
+    def test_effective_sample_rate_with_none(self, sample_text_content, sample_voice_settings):
+        """Test effective_sample_rate when sample_rate is None."""
+        request = SpeechSynthesisRequest(
+            text_content=sample_text_content,
+            voice_settings=sample_voice_settings,
+            sample_rate=None
+        )
+
+        assert request.effective_sample_rate == 22050  # Default value
+
+    def test_effective_sample_rate_with_value(self, sample_text_content, sample_voice_settings):
+        """Test effective_sample_rate when sample_rate has a value."""
+        request = SpeechSynthesisRequest(
+            text_content=sample_text_content,
+            voice_settings=sample_voice_settings,
+            sample_rate=44100
+        )
+
+        assert request.effective_sample_rate == 44100

tests/unit/domain/models/test_translation_request.py

@@ -7,266 +7,237 @@ from src.domain.models.text_content import TextContent
 
 class TestTranslationRequest:
     """Test cases for TranslationRequest value object."""
-    
-    def test_valid_translation_request_creation(self):
+
+    @pytest.fixture
+    def sample_text_content(self):
+        """Sample text content for testing."""
+        return TextContent(
+            text="Hello, world!",
+            language="en"
+        )
+
+    def test_valid_translation_request_creation(self, sample_text_content):
         """Test creating valid TranslationRequest instance."""
-        source_text = TextContent(text="Hello, world!", language="en")
         request = TranslationRequest(
-            source_text=source_text,
-            target_language="fr",
+            source_text=sample_text_content,
+            target_language="es",
             source_language="en"
         )
-        
-        assert request.source_text == source_text
-        assert request.target_language == "fr"
+
+        assert request.source_text == sample_text_content
+        assert request.target_language == "es"
         assert request.source_language == "en"
         assert request.effective_source_language == "en"
         assert request.is_auto_detect_source is False
-    
-    def test_translation_request_without_source_language(self):
+
+    def test_translation_request_without_source_language(self, sample_text_content):
         """Test creating TranslationRequest without explicit source language."""
-        source_text = TextContent(text="Hello, world!", language="en")
         request = TranslationRequest(
-            source_text=source_text,
-            target_language="fr"
+            source_text=sample_text_content,
+            target_language="es"
         )
-        
+
         assert request.source_language is None
         assert request.effective_source_language == "en"  # From TextContent
         assert request.is_auto_detect_source is True
-    
+
     def test_non_text_content_source_raises_error(self):
-        """Test that non-TextContent source_text raises TypeError."""
+        """Test that non-TextContent source raises TypeError."""
         with pytest.raises(TypeError, match="Source text must be a TextContent instance"):
             TranslationRequest(
-                source_text="Hello, world!",  # type: ignore
-                target_language="fr"
+                source_text="not a TextContent",  # type: ignore
+                target_language="es"
             )
-    
-    def test_non_string_target_language_raises_error(self):
-        """Test that non-string target_language raises TypeError."""
-        source_text = TextContent(text="Hello, world!", language="en")
+
+    def test_non_string_target_language_raises_error(self, sample_text_content):
+        """Test that non-string target language raises TypeError."""
         with pytest.raises(TypeError, match="Target language must be a string"):
             TranslationRequest(
-                source_text=source_text,
+                source_text=sample_text_content,
                 target_language=123  # type: ignore
             )
-    
-    def test_empty_target_language_raises_error(self):
-        """Test that empty target_language raises ValueError."""
-        source_text = TextContent(text="Hello, world!", language="en")
+
+    def test_empty_target_language_raises_error(self, sample_text_content):
+        """Test that empty target language raises ValueError."""
         with pytest.raises(ValueError, match="Target language cannot be empty"):
             TranslationRequest(
-                source_text=source_text,
+                source_text=sample_text_content,
                 target_language=""
             )
-    
-    def test_whitespace_target_language_raises_error(self):
-        """Test that whitespace-only target_language raises ValueError."""
-        source_text = TextContent(text="Hello, world!", language="en")
+
+    def test_whitespace_target_language_raises_error(self, sample_text_content):
+        """Test that whitespace-only target language raises ValueError."""
         with pytest.raises(ValueError, match="Target language cannot be empty"):
             TranslationRequest(
-                source_text=source_text,
+                source_text=sample_text_content,
                 target_language="   "
             )
-    
-    def test_invalid_target_language_format_raises_error(self):
+
+    def test_invalid_target_language_format_raises_error(self, sample_text_content):
         """Test that invalid target language format raises ValueError."""
-        source_text = TextContent(text="Hello, world!", language="en")
-        invalid_codes = ["f", "FRA", "fr-us", "fr-USA", "123", "fr_FR"]
-        
+        invalid_codes = ["e", "ENG", "en-us", "en-USA", "123", "en_US"]
+
         for code in invalid_codes:
             with pytest.raises(ValueError, match="Invalid target language code format"):
                 TranslationRequest(
-                    source_text=source_text,
+                    source_text=sample_text_content,
                     target_language=code
                 )
-    
-    def test_valid_target_language_codes(self):
+
+    def test_valid_target_language_codes(self, sample_text_content):
         """Test valid target language code formats."""
-        source_text = TextContent(text="Hello, world!", language="en")
-        valid_codes = ["fr", "de", "es", "zh", "ja", "fr-FR", "de-DE", "zh-CN"]
-        
+        valid_codes = ["es", "fr", "de", "zh", "ja", "en-US", "fr-FR", "zh-CN"]
+
         for code in valid_codes:
             request = TranslationRequest(
-                source_text=source_text,
+                source_text=sample_text_content,
                 target_language=code
             )
             assert request.target_language == code
-    
-    def test_non_string_source_language_raises_error(self):
-        """Test that non-string source_language raises TypeError."""
-        source_text = TextContent(text="Hello, world!", language="en")
+
+    def test_non_string_source_language_raises_error(self, sample_text_content):
+        """Test that non-string source language raises TypeError."""
         with pytest.raises(TypeError, match="Source language must be a string"):
             TranslationRequest(
-                source_text=source_text,
-                target_language="fr",
+                source_text=sample_text_content,
+                target_language="es",
                 source_language=123  # type: ignore
             )
-    
-    def test_empty_source_language_raises_error(self):
-        """Test that empty source_language raises ValueError."""
-        source_text = TextContent(text="Hello, world!", language="en")
+
+    def test_empty_source_language_raises_error(self, sample_text_content):
+        """Test that empty source language raises ValueError."""
         with pytest.raises(ValueError, match="Source language cannot be empty string"):
             TranslationRequest(
-                source_text=source_text,
-                target_language="fr",
+                source_text=sample_text_content,
+                target_language="es",
                 source_language=""
             )
-    
-    def test_whitespace_source_language_raises_error(self):
-        """Test that whitespace-only source_language raises ValueError."""
-        source_text = TextContent(text="Hello, world!", language="en")
+
+    def test_whitespace_source_language_raises_error(self, sample_text_content):
+        """Test that whitespace-only source language raises ValueError."""
         with pytest.raises(ValueError, match="Source language cannot be empty string"):
             TranslationRequest(
-                source_text=source_text,
-                target_language="fr",
+                source_text=sample_text_content,
+                target_language="es",
                 source_language="   "
             )
-    
-    def test_invalid_source_language_format_raises_error(self):
+
+    def test_invalid_source_language_format_raises_error(self, sample_text_content):
         """Test that invalid source language format raises ValueError."""
-        source_text = TextContent(text="Hello, world!", language="en")
         invalid_codes = ["e", "ENG", "en-us", "en-USA", "123", "en_US"]
-        
+
         for code in invalid_codes:
             with pytest.raises(ValueError, match="Invalid source language code format"):
                 TranslationRequest(
-                    source_text=source_text,
-                    target_language="fr",
+                    source_text=sample_text_content,
+                    target_language="es",
                     source_language=code
                 )
-    
-    def test_same_source_and_target_language_raises_error(self):
-        """Test that same source and target languages raise ValueError."""
-        source_text = TextContent(text="Hello, world!", language="en")
-        
-        # Explicit source language same as target
+
+    def test_same_source_and_target_language_explicit_raises_error(self, sample_text_content):
+        """Test that same explicit source and target language raises ValueError."""
         with pytest.raises(ValueError, match="Source and target languages cannot be the same"):
             TranslationRequest(
-                source_text=source_text,
+                source_text=sample_text_content,
                 target_language="en",
                 source_language="en"
             )
-        
-        # Implicit source language (from TextContent) same as target
+
+    def test_same_source_and_target_language_implicit_raises_error(self):
+        """Test that same implicit source and target language raises ValueError."""
+        text_content = TextContent(text="Hello", language="en")
+
         with pytest.raises(ValueError, match="Source and target languages cannot be the same"):
             TranslationRequest(
-                source_text=source_text,
-                target_language="en"
+                source_text=text_content,
+                target_language="en"  # Same as text_content.language
             )
-    
-    def test_effective_source_language_property(self):
-        """Test effective_source_language property."""
-        source_text = TextContent(text="Hello, world!", language="en")
-        
-        # With explicit source language
-        request_explicit = TranslationRequest(
-            source_text=source_text,
-            target_language="fr",
-            source_language="de"
-        )
-        assert request_explicit.effective_source_language == "de"
-        
-        # Without explicit source language (uses TextContent language)
-        request_implicit = TranslationRequest(
-            source_text=source_text,
-            target_language="fr"
-        )
-        assert request_implicit.effective_source_language == "en"
-    
-    def test_text_length_property(self):
+
+    def test_text_length_property(self, sample_text_content):
         """Test text_length property."""
-        source_text = TextContent(text="Hello, world!", language="en")
         request = TranslationRequest(
-            source_text=source_text,
-            target_language="fr"
+            source_text=sample_text_content,
+            target_language="es"
         )
-        
-        assert request.text_length == len("Hello, world!")
-    
-    def test_word_count_property(self):
+
+        assert request.text_length == len(sample_text_content.text)
+
+    def test_word_count_property(self, sample_text_content):
         """Test word_count property."""
-        source_text = TextContent(text="Hello, world!", language="en")
         request = TranslationRequest(
-            source_text=source_text,
-            target_language="fr"
+            source_text=sample_text_content,
+            target_language="es"
         )
-        
-        assert request.word_count == source_text.word_count
-    
-    def test_with_target_language_method(self):
+
+        assert request.word_count == sample_text_content.word_count
+
+    def test_with_target_language_method(self, sample_text_content):
         """Test with_target_language method creates new instance."""
-        source_text = TextContent(text="Hello, world!", language="en")
         original = TranslationRequest(
-            source_text=source_text,
-            target_language="fr",
+            source_text=sample_text_content,
+            target_language="es",
             source_language="en"
         )
-        
-        new_request = original.with_target_language("de")
-        
-        assert new_request.target_language == "de"
+
+        new_request = original.with_target_language("fr")
+
+        assert new_request.target_language == "fr"
         assert new_request.source_text == original.source_text
         assert new_request.source_language == original.source_language
         assert new_request is not original  # Different instances
-    
-    def test_with_source_language_method(self):
+
+    def test_with_source_language_method(self, sample_text_content):
         """Test with_source_language method creates new instance."""
-        source_text = TextContent(text="Hello, world!", language="en")
         original = TranslationRequest(
-            source_text=source_text,
-            target_language="fr",
+            source_text=sample_text_content,
+            target_language="es",
             source_language="en"
         )
-        
+
         new_request = original.with_source_language("de")
-        
+
         assert new_request.source_language == "de"
         assert new_request.target_language == original.target_language
         assert new_request.source_text == original.source_text
         assert new_request is not original  # Different instances
-    
-    def test_with_source_language_none(self):
+
+    def test_with_source_language_none(self, sample_text_content):
         """Test with_source_language method with None value."""
-        source_text = TextContent(text="Hello, world!", language="en")
         original = TranslationRequest(
-            source_text=source_text,
-            target_language="fr",
+            source_text=sample_text_content,
+            target_language="es",
             source_language="en"
         )
-        
+
         new_request = original.with_source_language(None)
         assert new_request.source_language is None
         assert new_request.is_auto_detect_source is True
-    
-    def test_translation_request_is_immutable(self):
+
+    def test_translation_request_is_immutable(self, sample_text_content):
         """Test that TranslationRequest is immutable (frozen dataclass)."""
-        source_text = TextContent(text="Hello, world!", language="en")
         request = TranslationRequest(
-            source_text=source_text,
-            target_language="fr"
+            source_text=sample_text_content,
+            target_language="es"
         )
-        
+
         with pytest.raises(AttributeError):
-            request.target_language = "de"  # type: ignore
-    
-    def test_valid_language_combinations(self):
-        """Test various valid language combinations."""
-        test_cases = [
-            ("en", "fr", "en"),  # English to French with explicit source
-            ("en", "de", None),  # English to German with auto-detect
-            ("fr-FR", "en-US", "fr"),  # Regional codes
-            ("zh", "ja", "zh-CN"),  # Asian languages
-        ]
-        
-        for text_lang, target_lang, source_lang in test_cases:
-            source_text = TextContent(text="Test text", language=text_lang)
-            request = TranslationRequest(
-                source_text=source_text,
-                target_language=target_lang,
-                source_language=source_lang
-            )
-            
-            assert request.target_language == target_lang
-            assert request.source_language == source_lang
+            request.target_language = "fr"  # type: ignore
+
+    def test_effective_source_language_with_explicit_source(self, sample_text_content):
+        """Test effective_source_language with explicit source language."""
+        request = TranslationRequest(
+            source_text=sample_text_content,
+            target_language="es",
+            source_language="de"  # Different from text_content.language
+        )
+
+        assert request.effective_source_language == "de"
+
+    def test_effective_source_language_with_implicit_source(self, sample_text_content):
+        """Test effective_source_language with implicit source language."""
+        request = TranslationRequest(
+            source_text=sample_text_content,
+            target_language="es"
+        )
+
+        assert request.effective_source_language == sample_text_content.language

tests/unit/domain/test_exceptions.py

@@ -0,0 +1,240 @@
+"""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