refactor based on DDD

.gitignore

@@ -44,4 +44,6 @@ htmlcov/
 .DS_Store
 
 #Secrets
-*.key
+*.key
+
+.kiro/

src/application/__init__.py

@@ -0,0 +1,3 @@
+"""Application layer package."""
+
+# Application services will be added in subsequent tasks

src/domain/__init__.py

@@ -0,0 +1,23 @@
+"""Domain layer package."""
+
+from .exceptions import (
+    DomainException,
+    InvalidAudioFormatException,
+    InvalidTextContentException,
+    TranslationFailedException,
+    SpeechRecognitionException,
+    SpeechSynthesisException,
+    InvalidVoiceSettingsException,
+    AudioProcessingException
+)
+
+__all__ = [
+    'DomainException',
+    'InvalidAudioFormatException',
+    'InvalidTextContentException',
+    'TranslationFailedException',
+    'SpeechRecognitionException',
+    'SpeechSynthesisException',
+    'InvalidVoiceSettingsException',
+    'AudioProcessingException'
+]

src/domain/exceptions.py

@@ -0,0 +1,41 @@
+"""Domain-specific exceptions for the TTS application."""
+
+
+class DomainException(Exception):
+    """Base exception for domain-related errors."""
+    pass
+
+
+class InvalidAudioFormatException(DomainException):
+    """Raised when audio format is not supported."""
+    pass
+
+
+class InvalidTextContentException(DomainException):
+    """Raised when text content is invalid."""
+    pass
+
+
+class TranslationFailedException(DomainException):
+    """Raised when translation fails."""
+    pass
+
+
+class SpeechRecognitionException(DomainException):
+    """Raised when speech recognition fails."""
+    pass
+
+
+class SpeechSynthesisException(DomainException):
+    """Raised when TTS generation fails."""
+    pass
+
+
+class InvalidVoiceSettingsException(DomainException):
+    """Raised when voice settings are invalid."""
+    pass
+
+
+class AudioProcessingException(DomainException):
+    """Raised when audio processing fails."""
+    pass

src/domain/interfaces/__init__.py

@@ -0,0 +1,13 @@
+"""Domain interfaces package."""
+
+from .speech_recognition import ISpeechRecognitionService
+from .translation import ITranslationService
+from .speech_synthesis import ISpeechSynthesisService
+from .audio_processing import IAudioProcessingService
+
+__all__ = [
+    'ISpeechRecognitionService',
+    'ITranslationService', 
+    'ISpeechSynthesisService',
+    'IAudioProcessingService'
+]

src/domain/interfaces/audio_processing.py

@@ -0,0 +1,36 @@
+"""Audio processing service interface."""
+
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ..models.audio_content import AudioContent
+    from ..models.voice_settings import VoiceSettings
+    from ..models.processing_result import ProcessingResult
+
+
+class IAudioProcessingService(ABC):
+    """Interface for audio processing pipeline orchestration."""
+    
+    @abstractmethod
+    def process_audio_pipeline(
+        self, 
+        audio: 'AudioContent', 
+        target_language: str, 
+        voice_settings: 'VoiceSettings'
+    ) -> 'ProcessingResult':
+        """
+        Process audio through the complete pipeline: STT -> Translation -> TTS.
+        
+        Args:
+            audio: The input audio content
+            target_language: The target language for translation
+            voice_settings: Voice settings for TTS synthesis
+            
+        Returns:
+            ProcessingResult: The result of the complete processing pipeline
+            
+        Raises:
+            AudioProcessingException: If any step in the pipeline fails
+        """
+        pass

src/domain/interfaces/speech_recognition.py

@@ -0,0 +1,29 @@
+"""Speech recognition service interface."""
+
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ..models.audio_content import AudioContent
+    from ..models.text_content import TextContent
+
+
+class ISpeechRecognitionService(ABC):
+    """Interface for speech recognition services."""
+    
+    @abstractmethod
+    def transcribe(self, audio: 'AudioContent', model: str) -> 'TextContent':
+        """
+        Transcribe audio content to text.
+        
+        Args:
+            audio: The audio content to transcribe
+            model: The STT model to use for transcription
+            
+        Returns:
+            TextContent: The transcribed text
+            
+        Raises:
+            SpeechRecognitionException: If transcription fails
+        """
+        pass

src/domain/interfaces/speech_synthesis.py

@@ -0,0 +1,44 @@
+"""Speech synthesis service interface."""
+
+from abc import ABC, abstractmethod
+from typing import Iterator, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ..models.speech_synthesis_request import SpeechSynthesisRequest
+    from ..models.audio_content import AudioContent, AudioChunk
+
+
+class ISpeechSynthesisService(ABC):
+    """Interface for speech synthesis services."""
+    
+    @abstractmethod
+    def synthesize(self, request: 'SpeechSynthesisRequest') -> 'AudioContent':
+        """
+        Synthesize speech from text.
+        
+        Args:
+            request: The speech synthesis request containing text and voice settings
+            
+        Returns:
+            AudioContent: The synthesized audio
+            
+        Raises:
+            SpeechSynthesisException: If synthesis fails
+        """
+        pass
+    
+    @abstractmethod
+    def synthesize_stream(self, request: 'SpeechSynthesisRequest') -> Iterator['AudioChunk']:
+        """
+        Synthesize speech from text as a stream.
+        
+        Args:
+            request: The speech synthesis request containing text and voice settings
+            
+        Returns:
+            Iterator[AudioChunk]: Stream of audio chunks
+            
+        Raises:
+            SpeechSynthesisException: If synthesis fails
+        """
+        pass

src/domain/interfaces/translation.py

@@ -0,0 +1,28 @@
+"""Translation service interface."""
+
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ..models.translation_request import TranslationRequest
+    from ..models.text_content import TextContent
+
+
+class ITranslationService(ABC):
+    """Interface for translation services."""
+    
+    @abstractmethod
+    def translate(self, request: 'TranslationRequest') -> 'TextContent':
+        """
+        Translate text from source language to target language.
+        
+        Args:
+            request: The translation request containing text and language info
+            
+        Returns:
+            TextContent: The translated text
+            
+        Raises:
+            TranslationFailedException: If translation fails
+        """
+        pass

src/domain/models/__init__.py

@@ -0,0 +1,15 @@
+"""Domain models package for value objects and entities."""
+
+from .audio_content import AudioContent
+from .text_content import TextContent
+from .voice_settings import VoiceSettings
+from .translation_request import TranslationRequest
+from .speech_synthesis_request import SpeechSynthesisRequest
+
+__all__ = [
+    'AudioContent',
+    'TextContent',
+    'VoiceSettings',
+    'TranslationRequest',
+    'SpeechSynthesisRequest',
+]

src/domain/models/audio_content.py

@@ -0,0 +1,55 @@
+"""AudioContent value object for representing audio data with validation."""
+
+from dataclasses import dataclass
+from typing import Optional
+
+
+@dataclass(frozen=True)
+class AudioContent:
+    """Value object representing audio content with metadata and validation."""
+    
+    data: bytes
+    format: str
+    sample_rate: int
+    duration: float
+    filename: Optional[str] = None
+    
+    def __post_init__(self):
+        """Validate audio content after initialization."""
+        self._validate()
+    
+    def _validate(self):
+        """Validate audio content properties."""
+        if not self.data:
+            raise ValueError("Audio data cannot be empty")
+        
+        if not isinstance(self.data, bytes):
+            raise TypeError("Audio data must be bytes")
+        
+        if self.format not in ['wav', 'mp3', 'flac', 'ogg']:
+            raise ValueError(f"Unsupported audio format: {self.format}. Supported formats: wav, mp3, flac, ogg")
+        
+        if self.sample_rate <= 0:
+            raise ValueError("Sample rate must be positive")
+        
+        if self.sample_rate < 8000 or self.sample_rate > 192000:
+            raise ValueError("Sample rate must be between 8000 and 192000 Hz")
+        
+        if self.duration <= 0:
+            raise ValueError("Duration must be positive")
+        
+        if self.duration > 3600:  # 1 hour limit
+            raise ValueError("Audio duration cannot exceed 1 hour")
+        
+        if self.filename is not None and not self.filename.strip():
+            raise ValueError("Filename cannot be empty string")
+    
+    @property
+    def size_bytes(self) -> int:
+        """Get the size of audio data in bytes."""
+        return len(self.data)
+    
+    @property
+    def is_valid_format(self) -> bool:
+        """Check if the audio format is valid."""
+        return self.format in ['wav', 'mp3', 'flac', 'ogg']

src/domain/models/speech_synthesis_request.py

@@ -0,0 +1,93 @@
+"""SpeechSynthesisRequest value object for TTS synthesis requests."""
+
+from dataclasses import dataclass
+from typing import Optional
+from .text_content import TextContent
+from .voice_settings import VoiceSettings
+
+
+@dataclass(frozen=True)
+class SpeechSynthesisRequest:
+    """Value object representing a speech synthesis request."""
+    
+    text: TextContent
+    voice_settings: VoiceSettings
+    output_format: str = 'wav'
+    sample_rate: Optional[int] = None
+    
+    def __post_init__(self):
+        """Validate speech synthesis request after initialization."""
+        self._validate()
+    
+    def _validate(self):
+        """Validate speech synthesis request properties."""
+        if not isinstance(self.text, TextContent):
+            raise TypeError("Text must be a TextContent instance")
+        
+        if not isinstance(self.voice_settings, VoiceSettings):
+            raise TypeError("Voice settings must be a VoiceSettings instance")
+        
+        if not isinstance(self.output_format, str):
+            raise TypeError("Output format must be a string")
+        
+        if self.output_format not in ['wav', 'mp3', 'flac', 'ogg']:
+            raise ValueError(f"Unsupported output format: {self.output_format}. Supported formats: wav, mp3, flac, ogg")
+        
+        if self.sample_rate is not None:
+            if not isinstance(self.sample_rate, int):
+                raise TypeError("Sample rate must be an integer")
+            
+            if self.sample_rate <= 0:
+                raise ValueError("Sample rate must be positive")
+            
+            if self.sample_rate < 8000 or self.sample_rate > 192000:
+                raise ValueError("Sample rate must be between 8000 and 192000 Hz")
+        
+        # Validate that text and voice settings have compatible languages
+        if self.text.language != self.voice_settings.language:
+            raise ValueError(f"Text language ({self.text.language}) must match voice language ({self.voice_settings.language})")
+    
+    @property
+    def estimated_duration_seconds(self) -> float:
+        """Estimate the duration of synthesized speech in seconds."""
+        # Rough estimation: average speaking rate is about 150-200 words per minute
+        # Adjusted by speed setting
+        words_per_minute = 175 / self.voice_settings.speed
+        return (self.text.word_count / words_per_minute) * 60
+    
+    @property
+    def is_long_text(self) -> bool:
+        """Check if the text is considered long for TTS processing."""
+        return self.text.character_count > 5000
+    
+    @property
+    def effective_sample_rate(self) -> int:
+        """Get the effective sample rate (default 22050 if not specified)."""
+        return self.sample_rate if self.sample_rate is not None else 22050
+    
+    def with_output_format(self, output_format: str) -> 'SpeechSynthesisRequest':
+        """Create a new SpeechSynthesisRequest with different output format."""
+        return SpeechSynthesisRequest(
+            text=self.text,
+            voice_settings=self.voice_settings,
+            output_format=output_format,
+            sample_rate=self.sample_rate
+        )
+    
+    def with_sample_rate(self, sample_rate: Optional[int]) -> 'SpeechSynthesisRequest':
+        """Create a new SpeechSynthesisRequest with different sample rate."""
+        return SpeechSynthesisRequest(
+            text=self.text,
+            voice_settings=self.voice_settings,
+            output_format=self.output_format,
+            sample_rate=sample_rate
+        )
+    
+    def with_voice_settings(self, voice_settings: VoiceSettings) -> 'SpeechSynthesisRequest':
+        """Create a new SpeechSynthesisRequest with different voice settings."""
+        return SpeechSynthesisRequest(
+            text=self.text,
+            voice_settings=voice_settings,
+            output_format=self.output_format,
+            sample_rate=self.sample_rate
+        )

src/domain/models/text_content.py

@@ -0,0 +1,81 @@
+"""TextContent value object for representing text data with language and encoding validation."""
+
+from dataclasses import dataclass
+from typing import Optional
+import re
+
+
+@dataclass(frozen=True)
+class TextContent:
+    """Value object representing text content with language and encoding information."""
+    
+    text: str
+    language: str
+    encoding: str = 'utf-8'
+    
+    def __post_init__(self):
+        """Validate text content after initialization."""
+        self._validate()
+    
+    def _validate(self):
+        """Validate text content properties."""
+        if not isinstance(self.text, str):
+            raise TypeError("Text must be a string")
+        
+        if not self.text.strip():
+            raise ValueError("Text content cannot be empty or whitespace only")
+        
+        if len(self.text) > 50000:  # Reasonable limit for TTS processing
+            raise ValueError("Text content too long (maximum 50,000 characters)")
+        
+        if not isinstance(self.language, str):
+            raise TypeError("Language must be a string")
+        
+        if not self.language.strip():
+            raise ValueError("Language cannot be empty")
+        
+        # Validate language code format (ISO 639-1 or ISO 639-3)
+        if not re.match(r'^[a-z]{2,3}(-[A-Z]{2})?$', self.language):
+            raise ValueError(f"Invalid language code format: {self.language}. Expected format: 'en', 'en-US', etc.")
+        
+        if not isinstance(self.encoding, str):
+            raise TypeError("Encoding must be a string")
+        
+        if self.encoding not in ['utf-8', 'utf-16', 'ascii', 'latin-1']:
+            raise ValueError(f"Unsupported encoding: {self.encoding}. Supported: utf-8, utf-16, ascii, latin-1")
+        
+        # Validate that text can be encoded with specified encoding
+        try:
+            self.text.encode(self.encoding)
+        except UnicodeEncodeError:
+            raise ValueError(f"Text cannot be encoded with {self.encoding} encoding")
+    
+    @property
+    def word_count(self) -> int:
+        """Get the approximate word count of the text."""
+        return len(self.text.split())
+    
+    @property
+    def character_count(self) -> int:
+        """Get the character count of the text."""
+        return len(self.text)
+    
+    @property
+    def is_empty(self) -> bool:
+        """Check if the text content is effectively empty."""
+        return not self.text.strip()
+    
+    def truncate(self, max_length: int) -> 'TextContent':
+        """Create a new TextContent with truncated text."""
+        if max_length <= 0:
+            raise ValueError("Max length must be positive")
+        
+        if len(self.text) <= max_length:
+            return self
+        
+        truncated_text = self.text[:max_length].rstrip()
+        return TextContent(
+            text=truncated_text,
+            language=self.language,
+            encoding=self.encoding
+        )

src/domain/models/translation_request.py

@@ -0,0 +1,89 @@
+"""TranslationRequest value object for translation service requests."""
+
+from dataclasses import dataclass
+from typing import Optional
+import re
+from .text_content import TextContent
+
+
+@dataclass(frozen=True)
+class TranslationRequest:
+    """Value object representing a translation request with source and target languages."""
+    
+    source_text: TextContent
+    target_language: str
+    source_language: Optional[str] = None
+    
+    def __post_init__(self):
+        """Validate translation request after initialization."""
+        self._validate()
+    
+    def _validate(self):
+        """Validate translation request properties."""
+        if not isinstance(self.source_text, TextContent):
+            raise TypeError("Source text must be a TextContent instance")
+        
+        if not isinstance(self.target_language, str):
+            raise TypeError("Target language must be a string")
+        
+        if not self.target_language.strip():
+            raise ValueError("Target language cannot be empty")
+        
+        # Validate target language code format (ISO 639-1 or ISO 639-3)
+        if not re.match(r'^[a-z]{2,3}(-[A-Z]{2})?$', self.target_language):
+            raise ValueError(f"Invalid target language code format: {self.target_language}. Expected format: 'en', 'en-US', etc.")
+        
+        if self.source_language is not None:
+            if not isinstance(self.source_language, str):
+                raise TypeError("Source language must be a string")
+            
+            if not self.source_language.strip():
+                raise ValueError("Source language cannot be empty string")
+            
+            # Validate source language code format
+            if not re.match(r'^[a-z]{2,3}(-[A-Z]{2})?$', self.source_language):
+                raise ValueError(f"Invalid source language code format: {self.source_language}. Expected format: 'en', 'en-US', etc.")
+            
+            # Check if source and target languages are the same
+            if self.source_language == self.target_language:
+                raise ValueError("Source and target languages cannot be the same")
+        
+        # If source language is not specified, use the language from TextContent
+        if self.source_language is None and self.source_text.language == self.target_language:
+            raise ValueError("Source and target languages cannot be the same")
+    
+    @property
+    def effective_source_language(self) -> str:
+        """Get the effective source language (from parameter or TextContent)."""
+        return self.source_language if self.source_language is not None else self.source_text.language
+    
+    @property
+    def is_auto_detect_source(self) -> bool:
+        """Check if source language should be auto-detected."""
+        return self.source_language is None
+    
+    @property
+    def text_length(self) -> int:
+        """Get the length of source text."""
+        return len(self.source_text.text)
+    
+    @property
+    def word_count(self) -> int:
+        """Get the word count of source text."""
+        return self.source_text.word_count
+    
+    def with_target_language(self, target_language: str) -> 'TranslationRequest':
+        """Create a new TranslationRequest with different target language."""
+        return TranslationRequest(
+            source_text=self.source_text,
+            target_language=target_language,
+            source_language=self.source_language
+        )
+    
+    def with_source_language(self, source_language: Optional[str]) -> 'TranslationRequest':
+        """Create a new TranslationRequest with different source language."""
+        return TranslationRequest(
+            source_text=self.source_text,
+            target_language=self.target_language,
+            source_language=source_language
+        )

src/domain/models/voice_settings.py

@@ -0,0 +1,97 @@
+"""VoiceSettings value object for TTS voice configuration with validation."""
+
+from dataclasses import dataclass
+from typing import Optional
+import re
+
+
+@dataclass(frozen=True)
+class VoiceSettings:
+    """Value object representing voice settings for text-to-speech synthesis."""
+    
+    voice_id: str
+    speed: float
+    language: str
+    pitch: Optional[float] = None
+    volume: Optional[float] = None
+    
+    def __post_init__(self):
+        """Validate voice settings after initialization."""
+        self._validate()
+    
+    def _validate(self):
+        """Validate voice settings properties."""
+        if not isinstance(self.voice_id, str):
+            raise TypeError("Voice ID must be a string")
+        
+        if not self.voice_id.strip():
+            raise ValueError("Voice ID cannot be empty")
+        
+        # Voice ID should be alphanumeric with possible underscores/hyphens
+        if not re.match(r'^[a-zA-Z0-9_-]+$', self.voice_id):
+            raise ValueError(f"Invalid voice ID format: {self.voice_id}. Must contain only letters, numbers, underscores, and hyphens")
+        
+        if not isinstance(self.speed, (int, float)):
+            raise TypeError("Speed must be a number")
+        
+        if not 0.1 <= self.speed <= 3.0:
+            raise ValueError(f"Speed must be between 0.1 and 3.0, got {self.speed}")
+        
+        if not isinstance(self.language, str):
+            raise TypeError("Language must be a string")
+        
+        if not self.language.strip():
+            raise ValueError("Language cannot be empty")
+        
+        # Validate language code format (ISO 639-1 or ISO 639-3)
+        if not re.match(r'^[a-z]{2,3}(-[A-Z]{2})?$', self.language):
+            raise ValueError(f"Invalid language code format: {self.language}. Expected format: 'en', 'en-US', etc.")
+        
+        if self.pitch is not None:
+            if not isinstance(self.pitch, (int, float)):
+                raise TypeError("Pitch must be a number")
+            
+            if not -2.0 <= self.pitch <= 2.0:
+                raise ValueError(f"Pitch must be between -2.0 and 2.0, got {self.pitch}")
+        
+        if self.volume is not None:
+            if not isinstance(self.volume, (int, float)):
+                raise TypeError("Volume must be a number")
+            
+            if not 0.0 <= self.volume <= 2.0:
+                raise ValueError(f"Volume must be between 0.0 and 2.0, got {self.volume}")
+    
+    @property
+    def is_default_speed(self) -> bool:
+        """Check if speed is at default value (1.0)."""
+        return abs(self.speed - 1.0) < 0.01
+    
+    @property
+    def is_default_pitch(self) -> bool:
+        """Check if pitch is at default value (0.0 or None)."""
+        return self.pitch is None or abs(self.pitch) < 0.01
+    
+    @property
+    def is_default_volume(self) -> bool:
+        """Check if volume is at default value (1.0 or None)."""
+        return self.volume is None or abs(self.volume - 1.0) < 0.01
+    
+    def with_speed(self, speed: float) -> 'VoiceSettings':
+        """Create a new VoiceSettings with different speed."""
+        return VoiceSettings(
+            voice_id=self.voice_id,
+            speed=speed,
+            language=self.language,
+            pitch=self.pitch,
+            volume=self.volume
+        )
+    
+    def with_pitch(self, pitch: Optional[float]) -> 'VoiceSettings':
+        """Create a new VoiceSettings with different pitch."""
+        return VoiceSettings(
+            voice_id=self.voice_id,
+            speed=self.speed,
+            language=self.language,
+            pitch=pitch,
+            volume=self.volume
+        )

src/domain/services/__init__.py

@@ -0,0 +1,3 @@
+"""Domain services package."""
+
+# Services will be added in subsequent tasks

src/infrastructure/__init__.py

@@ -0,0 +1,3 @@
+"""Infrastructure layer package."""
+
+# Infrastructure implementations will be added in subsequent tasks

src/presentation/__init__.py

@@ -0,0 +1,3 @@
+"""Presentation layer package."""
+
+# Presentation components will be added in subsequent tasks

tests/unit/domain/models/test_audio_content.py

@@ -0,0 +1,229 @@
+"""Unit tests for AudioContent value object."""
+
+import pytest
+from src.domain.models.audio_content import AudioContent
+
+
+class TestAudioContent:
+    """Test cases for AudioContent value object."""
+    
+    def test_valid_audio_content_creation(self):
+        """Test creating valid AudioContent instance."""
+        audio_data = b"fake_audio_data"
+        audio = AudioContent(
+            data=audio_data,
+            format="wav",
+            sample_rate=44100,
+            duration=10.5,
+            filename="test.wav"
+        )
+        
+        assert audio.data == audio_data
+        assert audio.format == "wav"
+        assert audio.sample_rate == 44100
+        assert audio.duration == 10.5
+        assert audio.filename == "test.wav"
+        assert audio.size_bytes == len(audio_data)
+        assert audio.is_valid_format is True
+    
+    def test_audio_content_without_filename(self):
+        """Test creating AudioContent without filename."""
+        audio = AudioContent(
+            data=b"fake_audio_data",
+            format="mp3",
+            sample_rate=22050,
+            duration=5.0
+        )
+        
+        assert audio.filename is None
+        assert audio.format == "mp3"
+    
+    def test_empty_audio_data_raises_error(self):
+        """Test that empty audio data raises ValueError."""
+        with pytest.raises(ValueError, match="Audio data cannot be empty"):
+            AudioContent(
+                data=b"",
+                format="wav",
+                sample_rate=44100,
+                duration=10.0
+            )
+    
+    def test_non_bytes_audio_data_raises_error(self):
+        """Test that non-bytes audio data raises TypeError."""
+        with pytest.raises(TypeError, match="Audio data must be bytes"):
+            AudioContent(
+                data="not_bytes",  # type: ignore
+                format="wav",
+                sample_rate=44100,
+                duration=10.0
+            )
+    
+    def test_unsupported_format_raises_error(self):
+        """Test that unsupported format raises ValueError."""
+        with pytest.raises(ValueError, match="Unsupported audio format: xyz"):
+            AudioContent(
+                data=b"fake_audio_data",
+                format="xyz",
+                sample_rate=44100,
+                duration=10.0
+            )
+    
+    def test_supported_formats(self):
+        """Test all supported audio formats."""
+        supported_formats = ['wav', 'mp3', 'flac', 'ogg']
+        
+        for fmt in supported_formats:
+            audio = AudioContent(
+                data=b"fake_audio_data",
+                format=fmt,
+                sample_rate=44100,
+                duration=10.0
+            )
+            assert audio.format == fmt
+            assert audio.is_valid_format is True
+    
+    def test_negative_sample_rate_raises_error(self):
+        """Test that negative sample rate raises ValueError."""
+        with pytest.raises(ValueError, match="Sample rate must be positive"):
+            AudioContent(
+                data=b"fake_audio_data",
+                format="wav",
+                sample_rate=-1,
+                duration=10.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 positive"):
+            AudioContent(
+                data=b"fake_audio_data",
+                format="wav",
+                sample_rate=0,
+                duration=10.0
+            )
+    
+    def test_sample_rate_too_low_raises_error(self):
+        """Test that sample rate below 8000 raises ValueError."""
+        with pytest.raises(ValueError, match="Sample rate must be between 8000 and 192000 Hz"):
+            AudioContent(
+                data=b"fake_audio_data",
+                format="wav",
+                sample_rate=7999,
+                duration=10.0
+            )
+    
+    def test_sample_rate_too_high_raises_error(self):
+        """Test that sample rate above 192000 raises ValueError."""
+        with pytest.raises(ValueError, match="Sample rate must be between 8000 and 192000 Hz"):
+            AudioContent(
+                data=b"fake_audio_data",
+                format="wav",
+                sample_rate=192001,
+                duration=10.0
+            )
+    
+    def test_valid_sample_rate_boundaries(self):
+        """Test valid sample rate boundaries."""
+        # Test minimum valid sample rate
+        audio_min = AudioContent(
+            data=b"fake_audio_data",
+            format="wav",
+            sample_rate=8000,
+            duration=10.0
+        )
+        assert audio_min.sample_rate == 8000
+        
+        # Test maximum valid sample rate
+        audio_max = AudioContent(
+            data=b"fake_audio_data",
+            format="wav",
+            sample_rate=192000,
+            duration=10.0
+        )
+        assert audio_max.sample_rate == 192000
+    
+    def test_negative_duration_raises_error(self):
+        """Test that negative duration raises ValueError."""
+        with pytest.raises(ValueError, match="Duration must be positive"):
+            AudioContent(
+                data=b"fake_audio_data",
+                format="wav",
+                sample_rate=44100,
+                duration=-1.0
+            )
+    
+    def test_zero_duration_raises_error(self):
+        """Test that zero duration raises ValueError."""
+        with pytest.raises(ValueError, match="Duration must be positive"):
+            AudioContent(
+                data=b"fake_audio_data",
+                format="wav",
+                sample_rate=44100,
+                duration=0.0
+            )
+    
+    def test_duration_too_long_raises_error(self):
+        """Test that duration over 1 hour raises ValueError."""
+        with pytest.raises(ValueError, match="Audio duration cannot exceed 1 hour"):
+            AudioContent(
+                data=b"fake_audio_data",
+                format="wav",
+                sample_rate=44100,
+                duration=3601.0  # 1 hour + 1 second
+            )
+    
+    def test_valid_duration_boundary(self):
+        """Test valid duration boundary (exactly 1 hour)."""
+        audio = AudioContent(
+            data=b"fake_audio_data",
+            format="wav",
+            sample_rate=44100,
+            duration=3600.0  # Exactly 1 hour
+        )
+        assert audio.duration == 3600.0
+    
+    def test_empty_filename_raises_error(self):
+        """Test that empty filename raises ValueError."""
+        with pytest.raises(ValueError, match="Filename cannot be empty string"):
+            AudioContent(
+                data=b"fake_audio_data",
+                format="wav",
+                sample_rate=44100,
+                duration=10.0,
+                filename=""
+            )
+    
+    def test_whitespace_filename_raises_error(self):
+        """Test that whitespace-only filename raises ValueError."""
+        with pytest.raises(ValueError, match="Filename cannot be empty string"):
+            AudioContent(
+                data=b"fake_audio_data",
+                format="wav",
+                sample_rate=44100,
+                duration=10.0,
+                filename="   "
+            )
+    
+    def test_audio_content_is_immutable(self):
+        """Test that AudioContent is immutable (frozen dataclass)."""
+        audio = AudioContent(
+            data=b"fake_audio_data",
+            format="wav",
+            sample_rate=44100,
+            duration=10.0
+        )
+        
+        with pytest.raises(AttributeError):
+            audio.format = "mp3"  # type: ignore
+    
+    def test_size_bytes_property(self):
+        """Test size_bytes property returns correct value."""
+        test_data = b"test_audio_data_123"
+        audio = AudioContent(
+            data=test_data,
+            format="wav",
+            sample_rate=44100,
+            duration=10.0
+        )
+        
+        assert audio.size_bytes == len(test_data)

tests/unit/domain/models/test_speech_synthesis_request.py

@@ -0,0 +1,349 @@
+"""Unit tests for SpeechSynthesisRequest value object."""
+
+import pytest
+from src.domain.models.speech_synthesis_request import SpeechSynthesisRequest
+from src.domain.models.text_content import TextContent
+from src.domain.models.voice_settings import VoiceSettings
+
+
+class TestSpeechSynthesisRequest:
+    """Test cases for SpeechSynthesisRequest value object."""
+    
+    def test_valid_speech_synthesis_request_creation(self):
+        """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,
+            output_format="wav",
+            sample_rate=44100
+        )
+        
+        assert request.text == text
+        assert request.voice_settings == 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):
+        """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
+        )
+        
+        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")
+        
+        with pytest.raises(TypeError, match="Text must be a TextContent instance"):
+            SpeechSynthesisRequest(
+                text="Hello, world!",  # type: ignore
+                voice_settings=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")
+        
+        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
+            )
+    
+    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")
+        
+        with pytest.raises(TypeError, match="Output format must be a string"):
+            SpeechSynthesisRequest(
+                text=text,
+                voice_settings=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")
+        
+        with pytest.raises(ValueError, match="Unsupported output format: xyz"):
+            SpeechSynthesisRequest(
+                text=text,
+                voice_settings=voice_settings,
+                output_format="xyz"
+            )
+    
+    def test_supported_output_formats(self):
+        """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,
+                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")
+        
+        with pytest.raises(TypeError, match="Sample rate must be an integer"):
+            SpeechSynthesisRequest(
+                text=text,
+                voice_settings=voice_settings,
+                sample_rate=44100.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")
+        
+        with pytest.raises(ValueError, match="Sample rate must be positive"):
+            SpeechSynthesisRequest(
+                text=text,
+                voice_settings=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")
+        
+        with pytest.raises(ValueError, match="Sample rate must be positive"):
+            SpeechSynthesisRequest(
+                text=text,
+                voice_settings=voice_settings,
+                sample_rate=0
+            )
+    
+    def test_sample_rate_too_low_raises_error(self):
+        """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,
+                sample_rate=7999
+            )
+    
+    def test_sample_rate_too_high_raises_error(self):
+        """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,
+                sample_rate=192001
+            )
+    
+    def test_valid_sample_rate_boundaries(self):
+        """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,
+            sample_rate=8000
+        )
+        assert request_min.sample_rate == 8000
+        
+        # Test maximum valid sample rate
+        request_max = SpeechSynthesisRequest(
+            text=text,
+            voice_settings=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\\)"):
+            SpeechSynthesisRequest(
+                text=text,
+                voice_settings=voice_settings
+            )
+    
+    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")
+        
+        request = SpeechSynthesisRequest(
+            text=text,
+            voice_settings=voice_settings
+        )
+        
+        assert request.text.language == "fr"
+        assert request.voice_settings.language == "fr"
+    
+    def test_estimated_duration_seconds_property(self):
+        """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
+        )
+        
+        # 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):
+        """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
+        )
+        assert request_explicit.effective_sample_rate == 44100
+        
+        # Without explicit sample rate (default)
+        request_default = SpeechSynthesisRequest(
+            text=text,
+            voice_settings=voice_settings
+        )
+        assert request_default.effective_sample_rate == 22050
+    
+    def test_with_output_format_method(self):
+        """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,
+            output_format="wav",
+            sample_rate=44100
+        )
+        
+        new_request = original.with_output_format("mp3")
+        
+        assert new_request.output_format == "mp3"
+        assert new_request.text == original.text
+        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):
+        """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
+        )
+        
+        new_request = original.with_sample_rate(22050)
+        
+        assert new_request.sample_rate == 22050
+        assert new_request.text == original.text
+        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):
+        """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
+        )
+        
+        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):
+        """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")
+        
+        original = SpeechSynthesisRequest(
+            text=text,
+            voice_settings=original_voice
+        )
+        
+        new_request = original.with_voice_settings(new_voice)
+        
+        assert new_request.voice_settings == new_voice
+        assert new_request.text == original.text
+        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):
+        """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
+        )
+        
+        with pytest.raises(AttributeError):
+            request.output_format = "mp3"  # type: ignore

tests/unit/domain/models/test_text_content.py

@@ -0,0 +1,240 @@
+"""Unit tests for TextContent value object."""
+
+import pytest
+from src.domain.models.text_content import TextContent
+
+
+class TestTextContent:
+    """Test cases for TextContent value object."""
+    
+    def test_valid_text_content_creation(self):
+        """Test creating valid TextContent instance."""
+        text = TextContent(
+            text="Hello, world!",
+            language="en",
+            encoding="utf-8"
+        )
+        
+        assert text.text == "Hello, world!"
+        assert text.language == "en"
+        assert text.encoding == "utf-8"
+        assert text.word_count == 2
+        assert text.character_count == 13
+        assert text.is_empty is False
+    
+    def test_text_content_with_default_encoding(self):
+        """Test creating TextContent with default encoding."""
+        text = TextContent(
+            text="Hello, world!",
+            language="en"
+        )
+        
+        assert text.encoding == "utf-8"
+    
+    def test_non_string_text_raises_error(self):
+        """Test that non-string text raises TypeError."""
+        with pytest.raises(TypeError, match="Text must be a string"):
+            TextContent(
+                text=123,  # type: ignore
+                language="en"
+            )
+    
+    def test_empty_text_raises_error(self):
+        """Test that empty text raises ValueError."""
+        with pytest.raises(ValueError, match="Text content cannot be empty or whitespace only"):
+            TextContent(
+                text="",
+                language="en"
+            )
+    
+    def test_whitespace_only_text_raises_error(self):
+        """Test that whitespace-only text raises ValueError."""
+        with pytest.raises(ValueError, match="Text content cannot be empty or whitespace only"):
+            TextContent(
+                text="   \n\t  ",
+                language="en"
+            )
+    
+    def test_text_too_long_raises_error(self):
+        """Test that text over 50,000 characters raises ValueError."""
+        long_text = "a" * 50001
+        with pytest.raises(ValueError, match="Text content too long"):
+            TextContent(
+                text=long_text,
+                language="en"
+            )
+    
+    def test_text_at_max_length(self):
+        """Test text at maximum allowed length."""
+        max_text = "a" * 50000
+        text = TextContent(
+            text=max_text,
+            language="en"
+        )
+        assert len(text.text) == 50000
+    
+    def test_non_string_language_raises_error(self):
+        """Test that non-string language raises TypeError."""
+        with pytest.raises(TypeError, match="Language must be a string"):
+            TextContent(
+                text="Hello",
+                language=123  # type: ignore
+            )
+    
+    def test_empty_language_raises_error(self):
+        """Test that empty language raises ValueError."""
+        with pytest.raises(ValueError, match="Language cannot be empty"):
+            TextContent(
+                text="Hello",
+                language=""
+            )
+    
+    def test_whitespace_language_raises_error(self):
+        """Test that whitespace-only language raises ValueError."""
+        with pytest.raises(ValueError, match="Language cannot be empty"):
+            TextContent(
+                text="Hello",
+                language="   "
+            )
+    
+    def test_invalid_language_code_format_raises_error(self):
+        """Test that invalid language code format raises ValueError."""
+        invalid_codes = ["e", "ENG", "en-us", "en-USA", "123", "en_US"]
+        
+        for code in invalid_codes:
+            with pytest.raises(ValueError, match="Invalid language code format"):
+                TextContent(
+                    text="Hello",
+                    language=code
+                )
+    
+    def test_valid_language_codes(self):
+        """Test valid language code formats."""
+        valid_codes = ["en", "fr", "de", "es", "zh", "ja", "en-US", "fr-FR", "zh-CN"]
+        
+        for code in valid_codes:
+            text = TextContent(
+                text="Hello",
+                language=code
+            )
+            assert text.language == code
+    
+    def test_non_string_encoding_raises_error(self):
+        """Test that non-string encoding raises TypeError."""
+        with pytest.raises(TypeError, match="Encoding must be a string"):
+            TextContent(
+                text="Hello",
+                language="en",
+                encoding=123  # type: ignore
+            )
+    
+    def test_unsupported_encoding_raises_error(self):
+        """Test that unsupported encoding raises ValueError."""
+        with pytest.raises(ValueError, match="Unsupported encoding: xyz"):
+            TextContent(
+                text="Hello",
+                language="en",
+                encoding="xyz"
+            )
+    
+    def test_supported_encodings(self):
+        """Test all supported encodings."""
+        supported_encodings = ['utf-8', 'utf-16', 'ascii', 'latin-1']
+        
+        for encoding in supported_encodings:
+            text = TextContent(
+                text="Hello",
+                language="en",
+                encoding=encoding
+            )
+            assert text.encoding == encoding
+    
+    def test_text_encoding_compatibility(self):
+        """Test that text is compatible with specified encoding."""
+        # ASCII text with UTF-8 encoding should work
+        text = TextContent(
+            text="Hello",
+            language="en",
+            encoding="ascii"
+        )
+        assert text.encoding == "ascii"
+        
+        # Unicode text with ASCII encoding should fail
+        with pytest.raises(ValueError, match="Text cannot be encoded with ascii encoding"):
+            TextContent(
+                text="Héllo",  # Contains non-ASCII character
+                language="en",
+                encoding="ascii"
+            )
+    
+    def test_word_count_property(self):
+        """Test word_count property calculation."""
+        test_cases = [
+            ("Hello world", 2),
+            ("Hello", 1),
+            ("Hello world test", 3),
+            ("Hello,  world!  Test.", 3),  # Multiple spaces and punctuation
+            ("", 1),  # Empty string split returns ['']
+        ]
+        
+        for text_str, expected_count in test_cases:
+            if text_str:  # Skip empty string test as it would fail validation
+                text = TextContent(text=text_str, language="en")
+                assert text.word_count == expected_count
+    
+    def test_character_count_property(self):
+        """Test character_count property."""
+        text_str = "Hello, world!"
+        text = TextContent(text=text_str, language="en")
+        assert text.character_count == len(text_str)
+    
+    def test_is_empty_property(self):
+        """Test is_empty property."""
+        # Non-empty text
+        text = TextContent(text="Hello", language="en")
+        assert text.is_empty is False
+        
+        # Text with only meaningful content
+        text2 = TextContent(text="  Hello  ", language="en")
+        assert text2.is_empty is False
+    
+    def test_truncate_method(self):
+        """Test truncate method."""
+        text = TextContent(text="Hello, world! This is a test.", language="en")
+        
+        # Truncate to shorter length
+        truncated = text.truncate(10)
+        assert len(truncated.text) <= 10
+        assert truncated.language == text.language
+        assert truncated.encoding == text.encoding
+        assert isinstance(truncated, TextContent)
+        
+        # Truncate to longer length (should return same)
+        not_truncated = text.truncate(100)
+        assert not_truncated.text == text.text
+    
+    def test_truncate_with_invalid_length(self):
+        """Test truncate with invalid max_length."""
+        text = TextContent(text="Hello", language="en")
+        
+        with pytest.raises(ValueError, match="Max length must be positive"):
+            text.truncate(0)
+        
+        with pytest.raises(ValueError, match="Max length must be positive"):
+            text.truncate(-1)
+    
+    def test_text_content_is_immutable(self):
+        """Test that TextContent is immutable (frozen dataclass)."""
+        text = TextContent(text="Hello", language="en")
+        
+        with pytest.raises(AttributeError):
+            text.text = "Goodbye"  # type: ignore
+    
+    def test_truncate_preserves_word_boundaries(self):
+        """Test that truncate method preserves word boundaries by rstripping."""
+        text = TextContent(text="Hello world test", language="en")
+        
+        # Truncate in middle of word
+        truncated = text.truncate(12)  # "Hello world " -> "Hello world" after rstrip
+        assert not truncated.text.endswith(" ")
+        assert truncated.text == "Hello world"

tests/unit/domain/models/test_translation_request.py

@@ -0,0 +1,272 @@
+"""Unit tests for TranslationRequest value object."""
+
+import pytest
+from src.domain.models.translation_request import TranslationRequest
+from src.domain.models.text_content import TextContent
+
+
+class TestTranslationRequest:
+    """Test cases for TranslationRequest value object."""
+    
+    def test_valid_translation_request_creation(self):
+        """Test creating valid TranslationRequest instance."""
+        source_text = TextContent(text="Hello, world!", language="en")
+        request = TranslationRequest(
+            source_text=source_text,
+            target_language="fr",
+            source_language="en"
+        )
+        
+        assert request.source_text == source_text
+        assert request.target_language == "fr"
+        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):
+        """Test creating TranslationRequest without explicit source language."""
+        source_text = TextContent(text="Hello, world!", language="en")
+        request = TranslationRequest(
+            source_text=source_text,
+            target_language="fr"
+        )
+        
+        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."""
+        with pytest.raises(TypeError, match="Source text must be a TextContent instance"):
+            TranslationRequest(
+                source_text="Hello, world!",  # type: ignore
+                target_language="fr"
+            )
+    
+    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")
+        with pytest.raises(TypeError, match="Target language must be a string"):
+            TranslationRequest(
+                source_text=source_text,
+                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")
+        with pytest.raises(ValueError, match="Target language cannot be empty"):
+            TranslationRequest(
+                source_text=source_text,
+                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")
+        with pytest.raises(ValueError, match="Target language cannot be empty"):
+            TranslationRequest(
+                source_text=source_text,
+                target_language="   "
+            )
+    
+    def test_invalid_target_language_format_raises_error(self):
+        """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"]
+        
+        for code in invalid_codes:
+            with pytest.raises(ValueError, match="Invalid target language code format"):
+                TranslationRequest(
+                    source_text=source_text,
+                    target_language=code
+                )
+    
+    def test_valid_target_language_codes(self):
+        """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"]
+        
+        for code in valid_codes:
+            request = TranslationRequest(
+                source_text=source_text,
+                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")
+        with pytest.raises(TypeError, match="Source language must be a string"):
+            TranslationRequest(
+                source_text=source_text,
+                target_language="fr",
+                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")
+        with pytest.raises(ValueError, match="Source language cannot be empty string"):
+            TranslationRequest(
+                source_text=source_text,
+                target_language="fr",
+                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")
+        with pytest.raises(ValueError, match="Source language cannot be empty string"):
+            TranslationRequest(
+                source_text=source_text,
+                target_language="fr",
+                source_language="   "
+            )
+    
+    def test_invalid_source_language_format_raises_error(self):
+        """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_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
+        with pytest.raises(ValueError, match="Source and target languages cannot be the same"):
+            TranslationRequest(
+                source_text=source_text,
+                target_language="en",
+                source_language="en"
+            )
+        
+        # Implicit source language (from TextContent) same as target
+        with pytest.raises(ValueError, match="Source and target languages cannot be the same"):
+            TranslationRequest(
+                source_text=source_text,
+                target_language="en"
+            )
+    
+    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):
+        """Test text_length property."""
+        source_text = TextContent(text="Hello, world!", language="en")
+        request = TranslationRequest(
+            source_text=source_text,
+            target_language="fr"
+        )
+        
+        assert request.text_length == len("Hello, world!")
+    
+    def test_word_count_property(self):
+        """Test word_count property."""
+        source_text = TextContent(text="Hello, world!", language="en")
+        request = TranslationRequest(
+            source_text=source_text,
+            target_language="fr"
+        )
+        
+        assert request.word_count == source_text.word_count
+    
+    def test_with_target_language_method(self):
+        """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_language="en"
+        )
+        
+        new_request = original.with_target_language("de")
+        
+        assert new_request.target_language == "de"
+        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):
+        """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_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):
+        """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_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):
+        """Test that TranslationRequest is immutable (frozen dataclass)."""
+        source_text = TextContent(text="Hello, world!", language="en")
+        request = TranslationRequest(
+            source_text=source_text,
+            target_language="fr"
+        )
+        
+        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

tests/unit/domain/models/test_voice_settings.py

@@ -0,0 +1,408 @@
+"""Unit tests for VoiceSettings value object."""
+
+import pytest
+from src.domain.models.voice_settings import VoiceSettings
+
+
+class TestVoiceSettings:
+    """Test cases for VoiceSettings value object."""
+    
+    def test_valid_voice_settings_creation(self):
+        """Test creating valid VoiceSettings instance."""
+        settings = VoiceSettings(
+            voice_id="en_male_001",
+            speed=1.2,
+            language="en",
+            pitch=0.1,
+            volume=0.8
+        )
+        
+        assert settings.voice_id == "en_male_001"
+        assert settings.speed == 1.2
+        assert settings.language == "en"
+        assert settings.pitch == 0.1
+        assert settings.volume == 0.8
+    
+    def test_voice_settings_with_optional_none(self):
+        """Test creating VoiceSettings with optional parameters as None."""
+        settings = VoiceSettings(
+            voice_id="en_male_001",
+            speed=1.0,
+            language="en"
+        )
+        
+        assert settings.pitch is None
+        assert settings.volume is None
+    
+    def test_non_string_voice_id_raises_error(self):
+        """Test that non-string voice_id raises TypeError."""
+        with pytest.raises(TypeError, match="Voice ID must be a string"):
+            VoiceSettings(
+                voice_id=123,  # type: ignore
+                speed=1.0,
+                language="en"
+            )
+    
+    def test_empty_voice_id_raises_error(self):
+        """Test that empty voice_id raises ValueError."""
+        with pytest.raises(ValueError, match="Voice ID cannot be empty"):
+            VoiceSettings(
+                voice_id="",
+                speed=1.0,
+                language="en"
+            )
+    
+    def test_whitespace_voice_id_raises_error(self):
+        """Test that whitespace-only voice_id raises ValueError."""
+        with pytest.raises(ValueError, match="Voice ID cannot be empty"):
+            VoiceSettings(
+                voice_id="   ",
+                speed=1.0,
+                language="en"
+            )
+    
+    def test_invalid_voice_id_format_raises_error(self):
+        """Test that invalid voice_id format raises ValueError."""
+        invalid_ids = ["voice id", "voice@id", "voice.id", "voice/id", "voice\\id"]
+        
+        for voice_id in invalid_ids:
+            with pytest.raises(ValueError, match="Invalid voice ID format"):
+                VoiceSettings(
+                    voice_id=voice_id,
+                    speed=1.0,
+                    language="en"
+                )
+    
+    def test_valid_voice_id_formats(self):
+        """Test valid voice_id formats."""
+        valid_ids = ["voice1", "voice_1", "voice-1", "en_male_001", "female-voice", "Voice123"]
+        
+        for voice_id in valid_ids:
+            settings = VoiceSettings(
+                voice_id=voice_id,
+                speed=1.0,
+                language="en"
+            )
+            assert settings.voice_id == voice_id
+    
+    def test_non_numeric_speed_raises_error(self):
+        """Test that non-numeric speed raises TypeError."""
+        with pytest.raises(TypeError, match="Speed must be a number"):
+            VoiceSettings(
+                voice_id="voice1",
+                speed="fast",  # type: ignore
+                language="en"
+            )
+    
+    def test_speed_too_low_raises_error(self):
+        """Test that speed below 0.1 raises ValueError."""
+        with pytest.raises(ValueError, match="Speed must be between 0.1 and 3.0"):
+            VoiceSettings(
+                voice_id="voice1",
+                speed=0.05,
+                language="en"
+            )
+    
+    def test_speed_too_high_raises_error(self):
+        """Test that speed above 3.0 raises ValueError."""
+        with pytest.raises(ValueError, match="Speed must be between 0.1 and 3.0"):
+            VoiceSettings(
+                voice_id="voice1",
+                speed=3.1,
+                language="en"
+            )
+    
+    def test_valid_speed_boundaries(self):
+        """Test valid speed boundaries."""
+        # Test minimum valid speed
+        settings_min = VoiceSettings(
+            voice_id="voice1",
+            speed=0.1,
+            language="en"
+        )
+        assert settings_min.speed == 0.1
+        
+        # Test maximum valid speed
+        settings_max = VoiceSettings(
+            voice_id="voice1",
+            speed=3.0,
+            language="en"
+        )
+        assert settings_max.speed == 3.0
+    
+    def test_non_string_language_raises_error(self):
+        """Test that non-string language raises TypeError."""
+        with pytest.raises(TypeError, match="Language must be a string"):
+            VoiceSettings(
+                voice_id="voice1",
+                speed=1.0,
+                language=123  # type: ignore
+            )
+    
+    def test_empty_language_raises_error(self):
+        """Test that empty language raises ValueError."""
+        with pytest.raises(ValueError, match="Language cannot be empty"):
+            VoiceSettings(
+                voice_id="voice1",
+                speed=1.0,
+                language=""
+            )
+    
+    def test_invalid_language_code_format_raises_error(self):
+        """Test that invalid language code format raises ValueError."""
+        invalid_codes = ["e", "ENG", "en-us", "en-USA", "123", "en_US"]
+        
+        for code in invalid_codes:
+            with pytest.raises(ValueError, match="Invalid language code format"):
+                VoiceSettings(
+                    voice_id="voice1",
+                    speed=1.0,
+                    language=code
+                )
+    
+    def test_valid_language_codes(self):
+        """Test valid language code formats."""
+        valid_codes = ["en", "fr", "de", "es", "zh", "ja", "en-US", "fr-FR", "zh-CN"]
+        
+        for code in valid_codes:
+            settings = VoiceSettings(
+                voice_id="voice1",
+                speed=1.0,
+                language=code
+            )
+            assert settings.language == code
+    
+    def test_non_numeric_pitch_raises_error(self):
+        """Test that non-numeric pitch raises TypeError."""
+        with pytest.raises(TypeError, match="Pitch must be a number"):
+            VoiceSettings(
+                voice_id="voice1",
+                speed=1.0,
+                language="en",
+                pitch="high"  # type: ignore
+            )
+    
+    def test_pitch_too_low_raises_error(self):
+        """Test that pitch below -2.0 raises ValueError."""
+        with pytest.raises(ValueError, match="Pitch must be between -2.0 and 2.0"):
+            VoiceSettings(
+                voice_id="voice1",
+                speed=1.0,
+                language="en",
+                pitch=-2.1
+            )
+    
+    def test_pitch_too_high_raises_error(self):
+        """Test that pitch above 2.0 raises ValueError."""
+        with pytest.raises(ValueError, match="Pitch must be between -2.0 and 2.0"):
+            VoiceSettings(
+                voice_id="voice1",
+                speed=1.0,
+                language="en",
+                pitch=2.1
+            )
+    
+    def test_valid_pitch_boundaries(self):
+        """Test valid pitch boundaries."""
+        # Test minimum valid pitch
+        settings_min = VoiceSettings(
+            voice_id="voice1",
+            speed=1.0,
+            language="en",
+            pitch=-2.0
+        )
+        assert settings_min.pitch == -2.0
+        
+        # Test maximum valid pitch
+        settings_max = VoiceSettings(
+            voice_id="voice1",
+            speed=1.0,
+            language="en",
+            pitch=2.0
+        )
+        assert settings_max.pitch == 2.0
+    
+    def test_non_numeric_volume_raises_error(self):
+        """Test that non-numeric volume raises TypeError."""
+        with pytest.raises(TypeError, match="Volume must be a number"):
+            VoiceSettings(
+                voice_id="voice1",
+                speed=1.0,
+                language="en",
+                volume="loud"  # type: ignore
+            )
+    
+    def test_volume_too_low_raises_error(self):
+        """Test that volume below 0.0 raises ValueError."""
+        with pytest.raises(ValueError, match="Volume must be between 0.0 and 2.0"):
+            VoiceSettings(
+                voice_id="voice1",
+                speed=1.0,
+                language="en",
+                volume=-0.1
+            )
+    
+    def test_volume_too_high_raises_error(self):
+        """Test that volume above 2.0 raises ValueError."""
+        with pytest.raises(ValueError, match="Volume must be between 0.0 and 2.0"):
+            VoiceSettings(
+                voice_id="voice1",
+                speed=1.0,
+                language="en",
+                volume=2.1
+            )
+    
+    def test_valid_volume_boundaries(self):
+        """Test valid volume boundaries."""
+        # Test minimum valid volume
+        settings_min = VoiceSettings(
+            voice_id="voice1",
+            speed=1.0,
+            language="en",
+            volume=0.0
+        )
+        assert settings_min.volume == 0.0
+        
+        # Test maximum valid volume
+        settings_max = VoiceSettings(
+            voice_id="voice1",
+            speed=1.0,
+            language="en",
+            volume=2.0
+        )
+        assert settings_max.volume == 2.0
+    
+    def test_is_default_speed_property(self):
+        """Test is_default_speed property."""
+        # Default speed (1.0)
+        settings_default = VoiceSettings(
+            voice_id="voice1",
+            speed=1.0,
+            language="en"
+        )
+        assert settings_default.is_default_speed is True
+        
+        # Non-default speed
+        settings_non_default = VoiceSettings(
+            voice_id="voice1",
+            speed=1.5,
+            language="en"
+        )
+        assert settings_non_default.is_default_speed is False
+    
+    def test_is_default_pitch_property(self):
+        """Test is_default_pitch property."""
+        # Default pitch (None)
+        settings_none = VoiceSettings(
+            voice_id="voice1",
+            speed=1.0,
+            language="en"
+        )
+        assert settings_none.is_default_pitch is True
+        
+        # Default pitch (0.0)
+        settings_zero = VoiceSettings(
+            voice_id="voice1",
+            speed=1.0,
+            language="en",
+            pitch=0.0
+        )
+        assert settings_zero.is_default_pitch is True
+        
+        # Non-default pitch
+        settings_non_default = VoiceSettings(
+            voice_id="voice1",
+            speed=1.0,
+            language="en",
+            pitch=0.5
+        )
+        assert settings_non_default.is_default_pitch is False
+    
+    def test_is_default_volume_property(self):
+        """Test is_default_volume property."""
+        # Default volume (None)
+        settings_none = VoiceSettings(
+            voice_id="voice1",
+            speed=1.0,
+            language="en"
+        )
+        assert settings_none.is_default_volume is True
+        
+        # Default volume (1.0)
+        settings_one = VoiceSettings(
+            voice_id="voice1",
+            speed=1.0,
+            language="en",
+            volume=1.0
+        )
+        assert settings_one.is_default_volume is True
+        
+        # Non-default volume
+        settings_non_default = VoiceSettings(
+            voice_id="voice1",
+            speed=1.0,
+            language="en",
+            volume=0.5
+        )
+        assert settings_non_default.is_default_volume is False
+    
+    def test_with_speed_method(self):
+        """Test with_speed method creates new instance."""
+        original = VoiceSettings(
+            voice_id="voice1",
+            speed=1.0,
+            language="en",
+            pitch=0.1,
+            volume=0.8
+        )
+        
+        new_settings = original.with_speed(1.5)
+        
+        assert new_settings.speed == 1.5
+        assert new_settings.voice_id == original.voice_id
+        assert new_settings.language == original.language
+        assert new_settings.pitch == original.pitch
+        assert new_settings.volume == original.volume
+        assert new_settings is not original  # Different instances
+    
+    def test_with_pitch_method(self):
+        """Test with_pitch method creates new instance."""
+        original = VoiceSettings(
+            voice_id="voice1",
+            speed=1.0,
+            language="en",
+            pitch=0.1,
+            volume=0.8
+        )
+        
+        new_settings = original.with_pitch(0.5)
+        
+        assert new_settings.pitch == 0.5
+        assert new_settings.voice_id == original.voice_id
+        assert new_settings.speed == original.speed
+        assert new_settings.language == original.language
+        assert new_settings.volume == original.volume
+        assert new_settings is not original  # Different instances
+    
+    def test_with_pitch_none(self):
+        """Test with_pitch method with None value."""
+        original = VoiceSettings(
+            voice_id="voice1",
+            speed=1.0,
+            language="en",
+            pitch=0.1
+        )
+        
+        new_settings = original.with_pitch(None)
+        assert new_settings.pitch is None
+    
+    def test_voice_settings_is_immutable(self):
+        """Test that VoiceSettings is immutable (frozen dataclass)."""
+        settings = VoiceSettings(
+            voice_id="voice1",
+            speed=1.0,
+            language="en"
+        )
+        
+        with pytest.raises(AttributeError):
+            settings.speed = 1.5  # type: ignore