Create unit tests for infrastructure layer

tests/unit/infrastructure/__init__.py

@@ -0,0 +1 @@
+"""Infrastructure layer unit tests."""

tests/unit/infrastructure/base/__init__.py

@@ -0,0 +1 @@
+"""Base provider unit tests."""

tests/unit/infrastructure/base/test_stt_provider_base.py

@@ -0,0 +1,359 @@
+"""Unit tests for STTProviderBase abstract class."""
+
+import pytest
+from unittest.mock import Mock, patch, MagicMock
+import tempfile
+from pathlib import Path
+
+from src.infrastructure.base.stt_provider_base import STTProviderBase
+from src.domain.models.audio_content import AudioContent
+from src.domain.models.text_content import TextContent
+from src.domain.exceptions import SpeechRecognitionException
+
+
+class ConcreteSTTProvider(STTProviderBase):
+    """Concrete implementation for testing."""
+    
+    def __init__(self, provider_name="test", supported_languages=None, available=True, models=None):
+        super().__init__(provider_name, supported_languages)
+        self._available = available
+        self._models = models or ["model1", "model2"]
+        self._should_fail = False
+        self._transcription_result = "Hello world"
+    
+    def _perform_transcription(self, audio_path, model):
+        if self._should_fail:
+            raise Exception("Test transcription error")
+        return self._transcription_result
+    
+    def is_available(self):
+        return self._available
+    
+    def get_available_models(self):
+        return self._models
+    
+    def get_default_model(self):
+        return self._models[0] if self._models else "default"
+    
+    def set_should_fail(self, should_fail):
+        self._should_fail = should_fail
+    
+    def set_transcription_result(self, result):
+        self._transcription_result = result
+
+
+class TestSTTProviderBase:
+    """Test cases for STTProviderBase abstract class."""
+    
+    def setup_method(self):
+        """Set up test fixtures."""
+        self.provider = ConcreteSTTProvider()
+        self.audio_content = AudioContent(
+            data=b"fake_audio_data",
+            format="wav",
+            sample_rate=16000,
+            duration=5.0,
+            filename="test.wav"
+        )
+    
+    def test_provider_initialization(self):
+        """Test provider initialization with default values."""
+        provider = ConcreteSTTProvider("test_provider", ["en", "es"])
+        
+        assert provider.provider_name == "test_provider"
+        assert provider.supported_languages == ["en", "es"]
+        assert isinstance(provider._temp_dir, Path)
+        assert provider._temp_dir.exists()
+    
+    def test_provider_initialization_no_languages(self):
+        """Test provider initialization without supported languages."""
+        provider = ConcreteSTTProvider("test_provider")
+        
+        assert provider.provider_name == "test_provider"
+        assert provider.supported_languages == []
+    
+    @patch('builtins.open', create=True)
+    def test_transcribe_success(self, mock_open):
+        """Test successful transcription."""
+        mock_file = MagicMock()
+        mock_open.return_value.__enter__.return_value = mock_file
+        
+        result = self.provider.transcribe(self.audio_content, "model1")
+        
+        assert isinstance(result, TextContent)
+        assert result.text == "Hello world"
+        assert result.language == "en"
+        assert result.encoding == "utf-8"
+    
+    def test_transcribe_empty_audio_fails(self):
+        """Test that empty audio data raises exception."""
+        empty_audio = AudioContent(
+            data=b"",
+            format="wav",
+            sample_rate=16000,
+            duration=0.1
+        )
+        
+        with pytest.raises(SpeechRecognitionException, match="Audio data cannot be empty"):
+            self.provider.transcribe(empty_audio, "model1")
+    
+    def test_transcribe_audio_too_long_fails(self):
+        """Test that audio longer than 1 hour raises exception."""
+        long_audio = AudioContent(
+            data=b"fake_audio_data",
+            format="wav",
+            sample_rate=16000,
+            duration=3601.0  # Over 1 hour
+        )
+        
+        with pytest.raises(SpeechRecognitionException, match="Audio duration exceeds maximum limit"):
+            self.provider.transcribe(long_audio, "model1")
+    
+    def test_transcribe_audio_too_short_fails(self):
+        """Test that audio shorter than 100ms raises exception."""
+        short_audio = AudioContent(
+            data=b"fake_audio_data",
+            format="wav",
+            sample_rate=16000,
+            duration=0.05  # 50ms
+        )
+        
+        with pytest.raises(SpeechRecognitionException, match="Audio duration too short"):
+            self.provider.transcribe(short_audio, "model1")
+    
+    def test_transcribe_invalid_format_fails(self):
+        """Test that invalid audio format raises exception."""
+        # Create audio with invalid format by mocking is_valid_format
+        invalid_audio = AudioContent(
+            data=b"fake_audio_data",
+            format="wav",
+            sample_rate=16000,
+            duration=5.0
+        )
+        
+        with patch.object(invalid_audio, 'is_valid_format', False):
+            with pytest.raises(SpeechRecognitionException, match="Unsupported audio format"):
+                self.provider.transcribe(invalid_audio, "model1")
+    
+    @patch('builtins.open', create=True)
+    def test_transcribe_provider_error(self, mock_open):
+        """Test handling of provider-specific errors."""
+        mock_file = MagicMock()
+        mock_open.return_value.__enter__.return_value = mock_file
+        
+        self.provider.set_should_fail(True)
+        
+        with pytest.raises(SpeechRecognitionException, match="STT transcription failed"):
+            self.provider.transcribe(self.audio_content, "model1")
+    
+    @patch('builtins.open', create=True)
+    @patch('pathlib.Path.unlink')
+    def test_transcribe_cleanup_temp_file(self, mock_unlink, mock_open):
+        """Test that temporary files are cleaned up."""
+        mock_file = MagicMock()
+        mock_open.return_value.__enter__.return_value = mock_file
+        
+        self.provider.transcribe(self.audio_content, "model1")
+        
+        # Verify cleanup was attempted
+        mock_unlink.assert_called()
+    
+    @patch('builtins.open', create=True)
+    def test_preprocess_audio(self, mock_open):
+        """Test audio preprocessing."""
+        mock_file = MagicMock()
+        mock_open.return_value.__enter__.return_value = mock_file
+        
+        processed_path = self.provider._preprocess_audio(self.audio_content)
+        
+        assert isinstance(processed_path, Path)
+        assert processed_path.suffix == ".wav"
+        mock_file.write.assert_called_once_with(self.audio_content.data)
+    
+    def test_preprocess_audio_error(self):
+        """Test audio preprocessing error handling."""
+        with patch('builtins.open', side_effect=IOError("Test error")):
+            with pytest.raises(SpeechRecognitionException, match="Audio preprocessing failed"):
+                self.provider._preprocess_audio(self.audio_content)
+    
+    @patch('pydub.AudioSegment.from_wav')
+    @patch('pydub.AudioSegment.export')
+    def test_convert_audio_format_wav(self, mock_export, mock_from_wav):
+        """Test audio format conversion for WAV."""
+        mock_audio = Mock()
+        mock_audio.set_frame_rate.return_value.set_channels.return_value = mock_audio
+        mock_from_wav.return_value = mock_audio
+        
+        test_path = Path("/tmp/test.wav")
+        result_path = self.provider._convert_audio_format(test_path, self.audio_content)
+        
+        mock_from_wav.assert_called_once_with(test_path)
+        mock_audio.set_frame_rate.assert_called_once_with(16000)
+        mock_audio.set_channels.assert_called_once_with(1)
+        mock_export.assert_called_once()
+    
+    @patch('pydub.AudioSegment.from_mp3')
+    def test_convert_audio_format_mp3(self, mock_from_mp3):
+        """Test audio format conversion for MP3."""
+        mp3_audio = AudioContent(
+            data=b"fake_mp3_data",
+            format="mp3",
+            sample_rate=44100,
+            duration=5.0
+        )
+        
+        mock_audio = Mock()
+        mock_audio.set_frame_rate.return_value.set_channels.return_value = mock_audio
+        mock_from_mp3.return_value = mock_audio
+        
+        test_path = Path("/tmp/test.mp3")
+        self.provider._convert_audio_format(test_path, mp3_audio)
+        
+        mock_from_mp3.assert_called_once_with(test_path)
+    
+    def test_convert_audio_format_no_pydub(self):
+        """Test audio format conversion when pydub is not available."""
+        test_path = Path("/tmp/test.wav")
+        
+        with patch('pydub.AudioSegment', side_effect=ImportError("pydub not available")):
+            result_path = self.provider._convert_audio_format(test_path, self.audio_content)
+            
+            # Should return original path when pydub is not available
+            assert result_path == test_path
+    
+    def test_convert_audio_format_error(self):
+        """Test audio format conversion error handling."""
+        test_path = Path("/tmp/test.wav")
+        
+        with patch('pydub.AudioSegment.from_wav', side_effect=Exception("Conversion error")):
+            result_path = self.provider._convert_audio_format(test_path, self.audio_content)
+            
+            # Should return original path on error
+            assert result_path == test_path
+    
+    def test_detect_language_english(self):
+        """Test language detection for English text."""
+        english_text = "The quick brown fox jumps over the lazy dog and it is very nice"
+        language = self.provider._detect_language(english_text)
+        assert language == "en"
+    
+    def test_detect_language_few_indicators(self):
+        """Test language detection with few English indicators."""
+        text = "Hello world"
+        language = self.provider._detect_language(text)
+        assert language == "en"
+    
+    def test_detect_language_no_indicators(self):
+        """Test language detection with no clear indicators."""
+        text = "xyz abc def"
+        language = self.provider._detect_language(text)
+        assert language == "en"  # Should default to English
+    
+    def test_detect_language_error(self):
+        """Test language detection error handling."""
+        with patch.object(self.provider, '_detect_language', side_effect=Exception("Detection error")):
+            language = self.provider._detect_language("test")
+            assert language is None
+    
+    def test_ensure_temp_directory(self):
+        """Test temporary directory creation."""
+        temp_dir = self.provider._ensure_temp_directory()
+        
+        assert isinstance(temp_dir, Path)
+        assert temp_dir.exists()
+        assert temp_dir.is_dir()
+        assert "stt_temp" in str(temp_dir)
+    
+    def test_cleanup_temp_file(self):
+        """Test temporary file cleanup."""
+        # Create a temporary file
+        temp_file = self.provider._temp_dir / "test_file.wav"
+        temp_file.touch()
+        
+        assert temp_file.exists()
+        
+        self.provider._cleanup_temp_file(temp_file)
+        
+        assert not temp_file.exists()
+    
+    def test_cleanup_temp_file_not_exists(self):
+        """Test cleanup of non-existent file."""
+        non_existent = Path("/tmp/non_existent_file.wav")
+        
+        # Should not raise exception
+        self.provider._cleanup_temp_file(non_existent)
+    
+    def test_cleanup_temp_file_error(self):
+        """Test cleanup error handling."""
+        with patch('pathlib.Path.unlink', side_effect=OSError("Permission denied")):
+            temp_file = Path("/tmp/test.wav")
+            
+            # Should not raise exception
+            self.provider._cleanup_temp_file(temp_file)
+    
+    @patch('time.time')
+    @patch('pathlib.Path.glob')
+    def test_cleanup_old_temp_files(self, mock_glob, mock_time):
+        """Test cleanup of old temporary files."""
+        mock_time.return_value = 1000000
+        
+        # Mock old file
+        old_file = Mock()
+        old_file.is_file.return_value = True
+        old_file.stat.return_value.st_mtime = 900000  # Old file
+        
+        # Mock recent file
+        recent_file = Mock()
+        recent_file.is_file.return_value = True
+        recent_file.stat.return_value.st_mtime = 999000  # Recent file
+        
+        mock_glob.return_value = [old_file, recent_file]
+        
+        self.provider._cleanup_old_temp_files(24)
+        
+        # Old file should be deleted
+        old_file.unlink.assert_called_once()
+        recent_file.unlink.assert_not_called()
+    
+    def test_cleanup_old_temp_files_error(self):
+        """Test cleanup error handling."""
+        with patch.object(self.provider._temp_dir, 'glob', side_effect=Exception("Test error")):
+            # Should not raise exception
+            self.provider._cleanup_old_temp_files()
+    
+    def test_handle_provider_error(self):
+        """Test provider error handling."""
+        original_error = ValueError("Original error")
+        
+        with pytest.raises(SpeechRecognitionException) as exc_info:
+            self.provider._handle_provider_error(original_error, "testing")
+        
+        assert "test error during testing: Original error" in str(exc_info.value)
+        assert exc_info.value.__cause__ is original_error
+    
+    def test_handle_provider_error_no_context(self):
+        """Test provider error handling without context."""
+        original_error = ValueError("Original error")
+        
+        with pytest.raises(SpeechRecognitionException) as exc_info:
+            self.provider._handle_provider_error(original_error)
+        
+        assert "test error: Original error" in str(exc_info.value)
+        assert exc_info.value.__cause__ is original_error
+    
+    def test_abstract_methods_not_implemented(self):
+        """Test that abstract methods raise NotImplementedError."""
+        # Create instance of base class directly (should fail)
+        with pytest.raises(TypeError):
+            STTProviderBase("test")
+    
+    def test_provider_unavailable(self):
+        """Test behavior when provider is unavailable."""
+        provider = ConcreteSTTProvider(available=False)
+        assert provider.is_available() is False
+    
+    def test_no_models_available(self):
+        """Test behavior when no models are available."""
+        provider = ConcreteSTTProvider(models=[])
+        assert provider.get_available_models() == []
+        assert provider.get_default_model() == "default"

tests/unit/infrastructure/base/test_translation_provider_base.py

@@ -0,0 +1,325 @@
+"""Unit tests for TranslationProviderBase abstract class."""
+
+import pytest
+from unittest.mock import Mock, patch
+
+from src.infrastructure.base.translation_provider_base import TranslationProviderBase
+from src.domain.models.translation_request import TranslationRequest
+from src.domain.models.text_content import TextContent
+from src.domain.exceptions import TranslationFailedException
+
+
+class ConcreteTranslationProvider(TranslationProviderBase):
+    """Concrete implementation for testing."""
+    
+    def __init__(self, provider_name="test", supported_languages=None, available=True):
+        super().__init__(provider_name, supported_languages)
+        self._available = available
+        self._should_fail = False
+        self._translation_result = "Translated text"
+    
+    def _translate_chunk(self, text, source_language, target_language):
+        if self._should_fail:
+            raise Exception("Test translation error")
+        return f"{self._translation_result} ({source_language}->{target_language})"
+    
+    def is_available(self):
+        return self._available
+    
+    def get_supported_languages(self):
+        return self.supported_languages
+    
+    def set_should_fail(self, should_fail):
+        self._should_fail = should_fail
+    
+    def set_translation_result(self, result):
+        self._translation_result = result
+
+
+class TestTranslationProviderBase:
+    """Test cases for TranslationProviderBase abstract class."""
+    
+    def setup_method(self):
+        """Set up test fixtures."""
+        self.provider = ConcreteTranslationProvider()
+        self.source_text = TextContent(text="Hello world", language="en")
+        self.request = TranslationRequest(
+            source_text=self.source_text,
+            target_language="es"
+        )
+    
+    def test_provider_initialization(self):
+        """Test provider initialization with default values."""
+        supported_langs = {"en": ["es", "fr"], "es": ["en"]}
+        provider = ConcreteTranslationProvider("test_provider", supported_langs)
+        
+        assert provider.provider_name == "test_provider"
+        assert provider.supported_languages == supported_langs
+        assert provider.max_chunk_length == 1000
+    
+    def test_provider_initialization_no_languages(self):
+        """Test provider initialization without supported languages."""
+        provider = ConcreteTranslationProvider("test_provider")
+        
+        assert provider.provider_name == "test_provider"
+        assert provider.supported_languages == {}
+    
+    def test_translate_success(self):
+        """Test successful translation."""
+        result = self.provider.translate(self.request)
+        
+        assert isinstance(result, TextContent)
+        assert result.text == "Translated text (en->es)"
+        assert result.language == "es"
+        assert result.encoding == "utf-8"
+    
+    def test_translate_with_language_validation(self):
+        """Test translation with language validation."""
+        supported_langs = {"en": ["es", "fr"], "es": ["en"]}
+        provider = ConcreteTranslationProvider("test", supported_langs)
+        
+        # Valid language pair should work
+        result = provider.translate(self.request)
+        assert isinstance(result, TextContent)
+        
+        # Invalid source language should fail
+        invalid_request = TranslationRequest(
+            source_text=TextContent(text="Hello", language="de"),
+            target_language="es"
+        )
+        
+        with pytest.raises(TranslationFailedException, match="Source language de not supported"):
+            provider.translate(invalid_request)
+        
+        # Invalid target language should fail
+        invalid_request2 = TranslationRequest(
+            source_text=self.source_text,
+            target_language="de"
+        )
+        
+        with pytest.raises(TranslationFailedException, match="Translation from en to de not supported"):
+            provider.translate(invalid_request2)
+    
+    def test_translate_empty_text_fails(self):
+        """Test that empty text raises exception."""
+        empty_request = TranslationRequest(
+            source_text=TextContent(text="", language="en"),
+            target_language="es"
+        )
+        
+        with pytest.raises(TranslationFailedException, match="Source text cannot be empty"):
+            self.provider.translate(empty_request)
+    
+    def test_translate_whitespace_text_fails(self):
+        """Test that whitespace-only text raises exception."""
+        whitespace_request = TranslationRequest(
+            source_text=TextContent(text="   ", language="en"),
+            target_language="es"
+        )
+        
+        with pytest.raises(TranslationFailedException, match="Source text cannot be empty"):
+            self.provider.translate(whitespace_request)
+    
+    def test_translate_same_language_fails(self):
+        """Test that same source and target language raises exception."""
+        same_lang_request = TranslationRequest(
+            source_text=self.source_text,
+            target_language="en"
+        )
+        
+        with pytest.raises(TranslationFailedException, match="Source and target languages cannot be the same"):
+            self.provider.translate(same_lang_request)
+    
+    def test_translate_provider_error(self):
+        """Test handling of provider-specific errors."""
+        self.provider.set_should_fail(True)
+        
+        with pytest.raises(TranslationFailedException, match="Translation failed"):
+            self.provider.translate(self.request)
+    
+    def test_translate_long_text_chunking(self):
+        """Test translation of long text with chunking."""
+        # Create long text that will be chunked
+        long_text = "This is a sentence. " * 100  # Much longer than default chunk size
+        long_request = TranslationRequest(
+            source_text=TextContent(text=long_text, language="en"),
+            target_language="es"
+        )
+        
+        result = self.provider.translate(long_request)
+        
+        assert isinstance(result, TextContent)
+        # Should contain multiple translated chunks
+        assert "Translated text (en->es)" in result.text
+    
+    def test_chunk_text_short_text(self):
+        """Test text chunking with short text."""
+        short_text = "Hello world"
+        chunks = self.provider._chunk_text(short_text)
+        
+        assert len(chunks) == 1
+        assert chunks[0] == short_text
+    
+    def test_chunk_text_long_text(self):
+        """Test text chunking with long text."""
+        # Create text longer than chunk size
+        long_text = "This is a sentence. " * 100
+        self.provider.max_chunk_length = 50  # Small chunk size for testing
+        
+        chunks = self.provider._chunk_text(long_text)
+        
+        assert len(chunks) > 1
+        for chunk in chunks:
+            assert len(chunk) <= self.provider.max_chunk_length
+    
+    def test_split_into_sentences(self):
+        """Test sentence splitting."""
+        text = "First sentence. Second sentence! Third sentence? Fourth sentence."
+        sentences = self.provider._split_into_sentences(text)
+        
+        assert len(sentences) == 4
+        assert "First sentence" in sentences[0]
+        assert "Second sentence" in sentences[1]
+        assert "Third sentence" in sentences[2]
+        assert "Fourth sentence" in sentences[3]
+    
+    def test_split_into_sentences_no_punctuation(self):
+        """Test sentence splitting with no punctuation."""
+        text = "Just one long sentence without proper punctuation"
+        sentences = self.provider._split_into_sentences(text)
+        
+        assert len(sentences) == 1
+        assert sentences[0] == text
+    
+    def test_split_long_sentence(self):
+        """Test splitting of long sentences by words."""
+        long_sentence = "word " * 100  # Very long sentence
+        self.provider.max_chunk_length = 20  # Small chunk size
+        
+        chunks = self.provider._split_long_sentence(long_sentence)
+        
+        assert len(chunks) > 1
+        for chunk in chunks:
+            assert len(chunk) <= self.provider.max_chunk_length
+    
+    def test_split_long_sentence_single_long_word(self):
+        """Test splitting with a single very long word."""
+        long_word = "a" * 100
+        self.provider.max_chunk_length = 20
+        
+        chunks = self.provider._split_long_sentence(long_word)
+        
+        assert len(chunks) == 1
+        assert chunks[0] == long_word  # Should include the long word as-is
+    
+    def test_reassemble_chunks(self):
+        """Test reassembling translated chunks."""
+        chunks = ["First chunk", "Second chunk", "Third chunk"]
+        result = self.provider._reassemble_chunks(chunks)
+        
+        assert result == "First chunk Second chunk Third chunk"
+    
+    def test_reassemble_chunks_with_empty(self):
+        """Test reassembling chunks with empty strings."""
+        chunks = ["First chunk", "", "Third chunk", "   "]
+        result = self.provider._reassemble_chunks(chunks)
+        
+        assert result == "First chunk Third chunk"
+    
+    def test_preprocess_text(self):
+        """Test text preprocessing."""
+        messy_text = "  Hello    world  \n\n  with   extra   spaces  "
+        processed = self.provider._preprocess_text(messy_text)
+        
+        assert processed == "Hello world with extra spaces"
+    
+    def test_postprocess_text(self):
+        """Test text postprocessing."""
+        messy_text = "Hello  world  .  This  is  a  test  !  Another  sentence  ?"
+        processed = self.provider._postprocess_text(messy_text)
+        
+        assert processed == "Hello world. This is a test! Another sentence?"
+    
+    def test_postprocess_text_sentence_spacing(self):
+        """Test postprocessing fixes sentence spacing."""
+        text = "First sentence.Second sentence!Third sentence?"
+        processed = self.provider._postprocess_text(text)
+        
+        assert processed == "First sentence. Second sentence! Third sentence?"
+    
+    def test_handle_provider_error(self):
+        """Test provider error handling."""
+        original_error = ValueError("Original error")
+        
+        with pytest.raises(TranslationFailedException) as exc_info:
+            self.provider._handle_provider_error(original_error, "testing")
+        
+        assert "test error during testing: Original error" in str(exc_info.value)
+        assert exc_info.value.__cause__ is original_error
+    
+    def test_handle_provider_error_no_context(self):
+        """Test provider error handling without context."""
+        original_error = ValueError("Original error")
+        
+        with pytest.raises(TranslationFailedException) as exc_info:
+            self.provider._handle_provider_error(original_error)
+        
+        assert "test error: Original error" in str(exc_info.value)
+        assert exc_info.value.__cause__ is original_error
+    
+    def test_set_chunk_size(self):
+        """Test setting chunk size."""
+        self.provider.set_chunk_size(500)
+        assert self.provider.max_chunk_length == 500
+    
+    def test_set_chunk_size_invalid(self):
+        """Test setting invalid chunk size."""
+        with pytest.raises(ValueError, match="Chunk size must be positive"):
+            self.provider.set_chunk_size(0)
+        
+        with pytest.raises(ValueError, match="Chunk size must be positive"):
+            self.provider.set_chunk_size(-1)
+    
+    def test_get_translation_stats(self):
+        """Test getting translation statistics."""
+        stats = self.provider.get_translation_stats(self.request)
+        
+        assert stats['provider'] == 'test'
+        assert stats['source_language'] == 'en'
+        assert stats['target_language'] == 'es'
+        assert stats['text_length'] == len(self.request.source_text.text)
+        assert stats['word_count'] == len(self.request.source_text.text.split())
+        assert stats['chunk_count'] >= 1
+        assert 'max_chunk_length' in stats
+        assert 'avg_chunk_length' in stats
+    
+    def test_get_translation_stats_empty_text(self):
+        """Test getting translation statistics for empty text."""
+        empty_request = TranslationRequest(
+            source_text=TextContent(text="", language="en"),
+            target_language="es"
+        )
+        
+        stats = self.provider.get_translation_stats(empty_request)
+        
+        assert stats['text_length'] == 0
+        assert stats['word_count'] == 0
+        assert stats['chunk_count'] == 0
+        assert stats['max_chunk_length'] == 0
+        assert stats['avg_chunk_length'] == 0
+    
+    def test_abstract_methods_not_implemented(self):
+        """Test that abstract methods raise NotImplementedError."""
+        # Create instance of base class directly (should fail)
+        with pytest.raises(TypeError):
+            TranslationProviderBase("test")
+    
+    def test_provider_unavailable(self):
+        """Test behavior when provider is unavailable."""
+        provider = ConcreteTranslationProvider(available=False)
+        assert provider.is_available() is False
+    
+    def test_no_supported_languages(self):
+        """Test behavior when no languages are supported."""
+        provider = ConcreteTranslationProvider(supported_languages={})
+        assert provider.get_supported_languages() == {}

tests/unit/infrastructure/base/test_tts_provider_base.py

@@ -0,0 +1,297 @@
+"""Unit tests for TTSProviderBase abstract class."""
+
+import pytest
+from unittest.mock import Mock, patch, MagicMock
+import tempfile
+from pathlib import Path
+import time
+
+from src.infrastructure.base.tts_provider_base import TTSProviderBase
+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
+from src.domain.models.audio_content import AudioContent
+from src.domain.models.audio_chunk import AudioChunk
+from src.domain.exceptions import SpeechSynthesisException
+
+
+class ConcreteTTSProvider(TTSProviderBase):
+    """Concrete implementation for testing."""
+    
+    def __init__(self, provider_name="test", supported_languages=None, available=True, voices=None):
+        super().__init__(provider_name, supported_languages)
+        self._available = available
+        self._voices = voices or ["voice1", "voice2"]
+        self._should_fail = False
+    
+    def _generate_audio(self, request):
+        if self._should_fail:
+            raise Exception("Test error")
+        return b"fake_audio_data", 44100
+    
+    def _generate_audio_stream(self, request):
+        if self._should_fail:
+            raise Exception("Test stream error")
+        chunks = [
+            (b"chunk1", 44100, False),
+            (b"chunk2", 44100, False),
+            (b"chunk3", 44100, True)
+        ]
+        for chunk in chunks:
+            yield chunk
+    
+    def is_available(self):
+        return self._available
+    
+    def get_available_voices(self):
+        return self._voices
+    
+    def set_should_fail(self, should_fail):
+        self._should_fail = should_fail
+
+
+class TestTTSProviderBase:
+    """Test cases for TTSProviderBase abstract class."""
+    
+    def setup_method(self):
+        """Set up test fixtures."""
+        self.provider = ConcreteTTSProvider()
+        self.text_content = TextContent(text="Hello world", language="en")
+        self.voice_settings = VoiceSettings(voice_id="voice1", speed=1.0, pitch=1.0)
+        self.request = SpeechSynthesisRequest(
+            text_content=self.text_content,
+            voice_settings=self.voice_settings
+        )
+    
+    def test_provider_initialization(self):
+        """Test provider initialization with default values."""
+        provider = ConcreteTTSProvider("test_provider", ["en", "es"])
+        
+        assert provider.provider_name == "test_provider"
+        assert provider.supported_languages == ["en", "es"]
+        assert isinstance(provider._output_dir, Path)
+        assert provider._output_dir.exists()
+    
+    def test_provider_initialization_no_languages(self):
+        """Test provider initialization without supported languages."""
+        provider = ConcreteTTSProvider("test_provider")
+        
+        assert provider.provider_name == "test_provider"
+        assert provider.supported_languages == []
+    
+    def test_synthesize_success(self):
+        """Test successful speech synthesis."""
+        result = self.provider.synthesize(self.request)
+        
+        assert isinstance(result, AudioContent)
+        assert result.data == b"fake_audio_data"
+        assert result.format == "wav"
+        assert result.sample_rate == 44100
+        assert result.duration > 0
+        assert "test_" in result.filename
+    
+    def test_synthesize_with_language_validation(self):
+        """Test synthesis with language validation."""
+        provider = ConcreteTTSProvider("test", ["en", "es"])
+        
+        # Valid language should work
+        result = provider.synthesize(self.request)
+        assert isinstance(result, AudioContent)
+        
+        # Invalid language should fail
+        invalid_request = SpeechSynthesisRequest(
+            text_content=TextContent(text="Hola", language="fr"),
+            voice_settings=self.voice_settings
+        )
+        
+        with pytest.raises(SpeechSynthesisException, match="Language fr not supported"):
+            provider.synthesize(invalid_request)
+    
+    def test_synthesize_with_voice_validation(self):
+        """Test synthesis with voice validation."""
+        provider = ConcreteTTSProvider("test", voices=["voice1", "voice2"])
+        
+        # Valid voice should work
+        result = provider.synthesize(self.request)
+        assert isinstance(result, AudioContent)
+        
+        # Invalid voice should fail
+        invalid_request = SpeechSynthesisRequest(
+            text_content=self.text_content,
+            voice_settings=VoiceSettings(voice_id="invalid_voice", speed=1.0, pitch=1.0)
+        )
+        
+        with pytest.raises(SpeechSynthesisException, match="Voice invalid_voice not available"):
+            provider.synthesize(invalid_request)
+    
+    def test_synthesize_empty_text_fails(self):
+        """Test that empty text raises exception."""
+        empty_request = SpeechSynthesisRequest(
+            text_content=TextContent(text="", language="en"),
+            voice_settings=self.voice_settings
+        )
+        
+        with pytest.raises(SpeechSynthesisException, match="Text content cannot be empty"):
+            self.provider.synthesize(empty_request)
+    
+    def test_synthesize_whitespace_text_fails(self):
+        """Test that whitespace-only text raises exception."""
+        whitespace_request = SpeechSynthesisRequest(
+            text_content=TextContent(text="   ", language="en"),
+            voice_settings=self.voice_settings
+        )
+        
+        with pytest.raises(SpeechSynthesisException, match="Text content cannot be empty"):
+            self.provider.synthesize(whitespace_request)
+    
+    def test_synthesize_provider_error(self):
+        """Test handling of provider-specific errors."""
+        self.provider.set_should_fail(True)
+        
+        with pytest.raises(SpeechSynthesisException, match="TTS synthesis failed"):
+            self.provider.synthesize(self.request)
+    
+    def test_synthesize_stream_success(self):
+        """Test successful streaming synthesis."""
+        chunks = list(self.provider.synthesize_stream(self.request))
+        
+        assert len(chunks) == 3
+        
+        for i, chunk in enumerate(chunks):
+            assert isinstance(chunk, AudioChunk)
+            assert chunk.data == f"chunk{i+1}".encode()
+            assert chunk.format == "wav"
+            assert chunk.sample_rate == 44100
+            assert chunk.chunk_index == i
+            assert chunk.timestamp > 0
+        
+        # Last chunk should be final
+        assert chunks[-1].is_final is True
+        assert chunks[0].is_final is False
+        assert chunks[1].is_final is False
+    
+    def test_synthesize_stream_provider_error(self):
+        """Test handling of provider errors in streaming."""
+        self.provider.set_should_fail(True)
+        
+        with pytest.raises(SpeechSynthesisException, match="TTS streaming synthesis failed"):
+            list(self.provider.synthesize_stream(self.request))
+    
+    def test_calculate_duration(self):
+        """Test audio duration calculation."""
+        # Test with standard parameters
+        audio_data = b"x" * 88200  # 1 second at 44100 Hz, 16-bit, mono
+        duration = self.provider._calculate_duration(audio_data, 44100)
+        assert duration == 1.0
+        
+        # Test with different sample rate
+        duration = self.provider._calculate_duration(audio_data, 22050)
+        assert duration == 2.0
+        
+        # Test with stereo
+        duration = self.provider._calculate_duration(audio_data, 44100, channels=2)
+        assert duration == 0.5
+        
+        # Test with empty data
+        duration = self.provider._calculate_duration(b"", 44100)
+        assert duration == 0.0
+        
+        # Test with zero sample rate
+        duration = self.provider._calculate_duration(audio_data, 0)
+        assert duration == 0.0
+    
+    def test_ensure_output_directory(self):
+        """Test output directory creation."""
+        output_dir = self.provider._ensure_output_directory()
+        
+        assert isinstance(output_dir, Path)
+        assert output_dir.exists()
+        assert output_dir.is_dir()
+        assert "tts_output" in str(output_dir)
+    
+    def test_generate_output_path(self):
+        """Test output path generation."""
+        path1 = self.provider._generate_output_path()
+        path2 = self.provider._generate_output_path()
+        
+        # Paths should be different (due to timestamp)
+        assert path1 != path2
+        assert path1.suffix == ".wav"
+        assert path2.suffix == ".wav"
+        assert "test_" in path1.name
+        assert "test_" in path2.name
+        
+        # Test with custom prefix and extension
+        path3 = self.provider._generate_output_path("custom", "mp3")
+        assert path3.suffix == ".mp3"
+        assert "custom_" in path3.name
+    
+    @patch('time.time')
+    @patch('pathlib.Path.glob')
+    @patch('pathlib.Path.stat')
+    @patch('pathlib.Path.unlink')
+    def test_cleanup_temp_files(self, mock_unlink, mock_stat, mock_glob, mock_time):
+        """Test temporary file cleanup."""
+        # Mock current time
+        mock_time.return_value = 1000000
+        
+        # Mock old file
+        old_file = Mock()
+        old_file.is_file.return_value = True
+        old_file.stat.return_value.st_mtime = 900000  # 100000 seconds old
+        
+        # Mock recent file
+        recent_file = Mock()
+        recent_file.is_file.return_value = True
+        recent_file.stat.return_value.st_mtime = 999000  # 1000 seconds old
+        
+        mock_glob.return_value = [old_file, recent_file]
+        
+        # Cleanup with 24 hour limit (86400 seconds)
+        self.provider._cleanup_temp_files(24)
+        
+        # Old file should be deleted, recent file should not
+        old_file.unlink.assert_called_once()
+        recent_file.unlink.assert_not_called()
+    
+    def test_cleanup_temp_files_error_handling(self):
+        """Test cleanup error handling."""
+        # Should not raise exception even if cleanup fails
+        with patch.object(self.provider._output_dir, 'glob', side_effect=Exception("Test error")):
+            self.provider._cleanup_temp_files()  # Should not raise
+    
+    def test_handle_provider_error(self):
+        """Test provider error handling."""
+        original_error = ValueError("Original error")
+        
+        with pytest.raises(SpeechSynthesisException) as exc_info:
+            self.provider._handle_provider_error(original_error, "testing")
+        
+        assert "test error during testing: Original error" in str(exc_info.value)
+        assert exc_info.value.__cause__ is original_error
+    
+    def test_handle_provider_error_no_context(self):
+        """Test provider error handling without context."""
+        original_error = ValueError("Original error")
+        
+        with pytest.raises(SpeechSynthesisException) as exc_info:
+            self.provider._handle_provider_error(original_error)
+        
+        assert "test error: Original error" in str(exc_info.value)
+        assert exc_info.value.__cause__ is original_error
+    
+    def test_abstract_methods_not_implemented(self):
+        """Test that abstract methods raise NotImplementedError."""
+        # Create instance of base class directly (should fail)
+        with pytest.raises(TypeError):
+            TTSProviderBase("test")
+    
+    def test_provider_unavailable(self):
+        """Test behavior when provider is unavailable."""
+        provider = ConcreteTTSProvider(available=False)
+        assert provider.is_available() is False
+    
+    def test_no_voices_available(self):
+        """Test behavior when no voices are available."""
+        provider = ConcreteTTSProvider(voices=[])
+        assert provider.get_available_voices() == []

tests/unit/infrastructure/config/__init__.py

@@ -0,0 +1 @@
+"""Configuration unit tests."""

tests/unit/infrastructure/config/test_dependency_container.py

@@ -0,0 +1,539 @@
+"""Unit tests for DependencyContainer."""
+
+import pytest
+from unittest.mock import Mock, patch, MagicMock
+from threading import Thread
+import time
+
+from src.infrastructure.config.dependency_container import (
+    DependencyContainer,
+    DependencyScope,
+    ServiceDescriptor,
+    ServiceLifetime,
+    get_container,
+    set_container,
+    cleanup_container
+)
+from src.infrastructure.config.app_config import AppConfig
+from src.infrastructure.tts.provider_factory import TTSProviderFactory
+from src.infrastructure.stt.provider_factory import STTProviderFactory
+from src.infrastructure.translation.provider_factory import TranslationProviderFactory, TranslationProviderType
+from src.domain.interfaces.speech_synthesis import ISpeechSynthesisService
+from src.domain.interfaces.speech_recognition import ISpeechRecognitionService
+from src.domain.interfaces.translation import ITranslationService
+
+
+class MockService:
+    """Mock service for testing."""
+    
+    def __init__(self, name="mock", **kwargs):
+        self.name = name
+        self.kwargs = kwargs
+        self.cleanup_called = False
+    
+    def cleanup(self):
+        self.cleanup_called = True
+
+
+class MockServiceWithDispose:
+    """Mock service with dispose method."""
+    
+    def __init__(self, name="mock"):
+        self.name = name
+        self.dispose_called = False
+    
+    def dispose(self):
+        self.dispose_called = True
+
+
+def mock_factory(**kwargs):
+    """Mock factory function."""
+    return MockService("factory_created", **kwargs)
+
+
+class TestServiceDescriptor:
+    """Test cases for ServiceDescriptor."""
+    
+    def test_service_descriptor_creation(self):
+        """Test service descriptor creation."""
+        descriptor = ServiceDescriptor(
+            service_type=MockService,
+            implementation=MockService,
+            lifetime=ServiceLifetime.SINGLETON,
+            factory_args={'name': 'test'}
+        )
+        
+        assert descriptor.service_type == MockService
+        assert descriptor.implementation == MockService
+        assert descriptor.lifetime == ServiceLifetime.SINGLETON
+        assert descriptor.factory_args == {'name': 'test'}
+    
+    def test_service_descriptor_defaults(self):
+        """Test service descriptor with default values."""
+        descriptor = ServiceDescriptor(
+            service_type=MockService,
+            implementation=MockService
+        )
+        
+        assert descriptor.lifetime == ServiceLifetime.TRANSIENT
+        assert descriptor.factory_args == {}
+
+
+class TestDependencyContainer:
+    """Test cases for DependencyContainer."""
+    
+    def setup_method(self):
+        """Set up test fixtures."""
+        self.container = DependencyContainer()
+    
+    def teardown_method(self):
+        """Clean up after tests."""
+        self.container.cleanup()
+    
+    def test_container_initialization(self):
+        """Test container initialization."""
+        assert isinstance(self.container._config, AppConfig)
+        assert isinstance(self.container._services, dict)
+        assert isinstance(self.container._singletons, dict)
+        assert isinstance(self.container._scoped_instances, dict)
+        
+        # Should have default services registered
+        assert AppConfig in self.container._singletons
+    
+    def test_container_initialization_with_config(self):
+        """Test container initialization with custom config."""
+        config = AppConfig()
+        container = DependencyContainer(config)
+        
+        assert container._config is config
+        assert AppConfig in container._singletons
+        assert container._singletons[AppConfig] is config
+    
+    def test_register_singleton_class(self):
+        """Test registering singleton service with class."""
+        self.container.register_singleton(MockService, MockService, {'name': 'test'})
+        
+        assert MockService in self.container._services
+        descriptor = self.container._services[MockService]
+        assert descriptor.lifetime == ServiceLifetime.SINGLETON
+        assert descriptor.factory_args == {'name': 'test'}
+    
+    def test_register_singleton_instance(self):
+        """Test registering singleton service with instance."""
+        instance = MockService("test_instance")
+        self.container.register_singleton(MockService, instance)
+        
+        assert MockService in self.container._singletons
+        assert self.container._singletons[MockService] is instance
+    
+    def test_register_singleton_factory(self):
+        """Test registering singleton service with factory function."""
+        self.container.register_singleton(MockService, mock_factory, {'name': 'factory_test'})
+        
+        service = self.container.resolve(MockService)
+        assert isinstance(service, MockService)
+        assert service.name == "factory_created"
+        assert service.kwargs == {'name': 'factory_test'}
+    
+    def test_register_transient(self):
+        """Test registering transient service."""
+        self.container.register_transient(MockService, MockService, {'name': 'transient'})
+        
+        assert MockService in self.container._services
+        descriptor = self.container._services[MockService]
+        assert descriptor.lifetime == ServiceLifetime.TRANSIENT
+    
+    def test_register_scoped(self):
+        """Test registering scoped service."""
+        self.container.register_scoped(MockService, MockService, {'name': 'scoped'})
+        
+        assert MockService in self.container._services
+        descriptor = self.container._services[MockService]
+        assert descriptor.lifetime == ServiceLifetime.SCOPED
+    
+    def test_resolve_singleton(self):
+        """Test resolving singleton service."""
+        self.container.register_singleton(MockService, MockService, {'name': 'singleton'})
+        
+        service1 = self.container.resolve(MockService)
+        service2 = self.container.resolve(MockService)
+        
+        assert service1 is service2
+        assert service1.name == 'singleton'
+    
+    def test_resolve_transient(self):
+        """Test resolving transient service."""
+        self.container.register_transient(MockService, MockService, {'name': 'transient'})
+        
+        service1 = self.container.resolve(MockService)
+        service2 = self.container.resolve(MockService)
+        
+        assert service1 is not service2
+        assert service1.name == 'transient'
+        assert service2.name == 'transient'
+    
+    def test_resolve_scoped(self):
+        """Test resolving scoped service."""
+        self.container.register_scoped(MockService, MockService, {'name': 'scoped'})
+        
+        service1 = self.container.resolve(MockService)
+        service2 = self.container.resolve(MockService)
+        
+        assert service1 is service2  # Same instance within scope
+        assert service1.name == 'scoped'
+    
+    def test_resolve_unregistered_service(self):
+        """Test resolving unregistered service raises error."""
+        class UnregisteredService:
+            pass
+        
+        with pytest.raises(ValueError, match="Service UnregisteredService is not registered"):
+            self.container.resolve(UnregisteredService)
+    
+    def test_resolve_service_creation_error(self):
+        """Test handling service creation errors."""
+        def failing_factory():
+            raise Exception("Creation failed")
+        
+        self.container.register_singleton(MockService, failing_factory)
+        
+        with pytest.raises(Exception, match="Creation failed"):
+            self.container.resolve(MockService)
+    
+    def test_thread_safety(self):
+        """Test container thread safety."""
+        self.container.register_singleton(MockService, MockService, {'name': 'thread_test'})
+        
+        results = []
+        
+        def resolve_service():
+            service = self.container.resolve(MockService)
+            results.append(service)
+        
+        threads = [Thread(target=resolve_service) for _ in range(10)]
+        
+        for thread in threads:
+            thread.start()
+        
+        for thread in threads:
+            thread.join()
+        
+        # All threads should get the same singleton instance
+        assert len(results) == 10
+        assert all(service is results[0] for service in results)
+    
+    def test_get_tts_provider_default(self):
+        """Test getting TTS provider with default settings."""
+        with patch.object(TTSProviderFactory, 'get_provider_with_fallback') as mock_get:
+            mock_provider = Mock()
+            mock_get.return_value = mock_provider
+            
+            provider = self.container.get_tts_provider()
+            
+            assert provider is mock_provider
+            mock_get.assert_called_once()
+    
+    def test_get_tts_provider_specific(self):
+        """Test getting specific TTS provider."""
+        with patch.object(TTSProviderFactory, 'create_provider') as mock_create:
+            mock_provider = Mock()
+            mock_create.return_value = mock_provider
+            
+            provider = self.container.get_tts_provider('kokoro', lang_code='en')
+            
+            assert provider is mock_provider
+            mock_create.assert_called_once_with('kokoro', lang_code='en')
+    
+    def test_get_stt_provider_default(self):
+        """Test getting STT provider with default settings."""
+        with patch.object(STTProviderFactory, 'create_provider_with_fallback') as mock_get:
+            mock_provider = Mock()
+            mock_get.return_value = mock_provider
+            
+            provider = self.container.get_stt_provider()
+            
+            assert provider is mock_provider
+            mock_get.assert_called_once()
+    
+    def test_get_stt_provider_specific(self):
+        """Test getting specific STT provider."""
+        with patch.object(STTProviderFactory, 'create_provider') as mock_create:
+            mock_provider = Mock()
+            mock_create.return_value = mock_provider
+            
+            provider = self.container.get_stt_provider('whisper')
+            
+            assert provider is mock_provider
+            mock_create.assert_called_once_with('whisper')
+    
+    def test_get_translation_provider_default(self):
+        """Test getting translation provider with default settings."""
+        with patch.object(TranslationProviderFactory, 'get_default_provider') as mock_get:
+            mock_provider = Mock()
+            mock_get.return_value = mock_provider
+            
+            provider = self.container.get_translation_provider()
+            
+            assert provider is mock_provider
+            mock_get.assert_called_once_with(None)
+    
+    def test_get_translation_provider_specific(self):
+        """Test getting specific translation provider."""
+        with patch.object(TranslationProviderFactory, 'create_provider') as mock_create:
+            mock_provider = Mock()
+            mock_create.return_value = mock_provider
+            
+            config = {'model': 'test'}
+            provider = self.container.get_translation_provider(TranslationProviderType.NLLB, config)
+            
+            assert provider is mock_provider
+            mock_create.assert_called_once_with(TranslationProviderType.NLLB, config)
+    
+    def test_clear_scoped_instances(self):
+        """Test clearing scoped instances."""
+        self.container.register_scoped(MockService, MockService)
+        
+        # Create scoped instance
+        service = self.container.resolve(MockService)
+        assert MockService in self.container._scoped_instances
+        
+        self.container.clear_scoped_instances()
+        
+        assert len(self.container._scoped_instances) == 0
+        assert service.cleanup_called is True
+    
+    def test_cleanup_instance_with_cleanup_method(self):
+        """Test cleanup of instance with cleanup method."""
+        instance = MockService()
+        self.container._cleanup_instance(instance)
+        
+        assert instance.cleanup_called is True
+    
+    def test_cleanup_instance_with_dispose_method(self):
+        """Test cleanup of instance with dispose method."""
+        instance = MockServiceWithDispose()
+        self.container._cleanup_instance(instance)
+        
+        assert instance.dispose_called is True
+    
+    def test_cleanup_instance_no_cleanup_method(self):
+        """Test cleanup of instance without cleanup method."""
+        instance = object()
+        
+        # Should not raise exception
+        self.container._cleanup_instance(instance)
+    
+    def test_cleanup_instance_error_handling(self):
+        """Test cleanup error handling."""
+        instance = Mock()
+        instance.cleanup.side_effect = Exception("Cleanup error")
+        
+        # Should not raise exception
+        self.container._cleanup_instance(instance)
+    
+    def test_cleanup_container(self):
+        """Test full container cleanup."""
+        # Register services
+        self.container.register_singleton(MockService, MockService)
+        self.container.register_scoped(MockServiceWithDispose, MockServiceWithDispose)
+        
+        # Create instances
+        singleton = self.container.resolve(MockService)
+        scoped = self.container.resolve(MockServiceWithDispose)
+        
+        # Mock factories
+        mock_tts_factory = Mock()
+        mock_translation_factory = Mock()
+        self.container._tts_factory = mock_tts_factory
+        self.container._translation_factory = mock_translation_factory
+        
+        self.container.cleanup()
+        
+        # Check cleanup was called
+        assert singleton.cleanup_called is True
+        assert scoped.dispose_called is True
+        mock_tts_factory.cleanup_providers.assert_called_once()
+        mock_translation_factory.clear_cache.assert_called_once()
+        
+        # Check instances were cleared
+        assert len(self.container._singletons) == 0
+        assert len(self.container._scoped_instances) == 0
+        assert self.container._tts_factory is None
+        assert self.container._translation_factory is None
+    
+    def test_cleanup_factory_error_handling(self):
+        """Test cleanup error handling for factories."""
+        mock_tts_factory = Mock()
+        mock_tts_factory.cleanup_providers.side_effect = Exception("TTS cleanup error")
+        self.container._tts_factory = mock_tts_factory
+        
+        # Should not raise exception
+        self.container.cleanup()
+    
+    def test_is_registered(self):
+        """Test checking if service is registered."""
+        assert self.container.is_registered(AppConfig) is True  # Default registration
+        assert self.container.is_registered(MockService) is False
+        
+        self.container.register_singleton(MockService, MockService)
+        assert self.container.is_registered(MockService) is True
+    
+    def test_get_registered_services(self):
+        """Test getting registered services info."""
+        self.container.register_singleton(MockService, MockService)
+        self.container.register_transient(MockServiceWithDispose, MockServiceWithDispose)
+        
+        services = self.container.get_registered_services()
+        
+        assert 'AppConfig' in services
+        assert 'MockService' in services
+        assert 'MockServiceWithDispose' in services
+        assert services['MockService'] == 'singleton'
+        assert services['MockServiceWithDispose'] == 'transient'
+    
+    def test_create_scope(self):
+        """Test creating dependency scope."""
+        scope = self.container.create_scope()
+        
+        assert isinstance(scope, DependencyScope)
+        assert scope._parent is self.container
+    
+    def test_context_manager(self):
+        """Test container as context manager."""
+        with DependencyContainer() as container:
+            container.register_singleton(MockService, MockService)
+            service = container.resolve(MockService)
+            
+            assert isinstance(service, MockService)
+        
+        # Cleanup should have been called
+        assert service.cleanup_called is True
+
+
+class TestDependencyScope:
+    """Test cases for DependencyScope."""
+    
+    def setup_method(self):
+        """Set up test fixtures."""
+        self.container = DependencyContainer()
+        self.scope = DependencyScope(self.container)
+    
+    def teardown_method(self):
+        """Clean up after tests."""
+        self.scope.cleanup()
+        self.container.cleanup()
+    
+    def test_scope_initialization(self):
+        """Test scope initialization."""
+        assert self.scope._parent is self.container
+        assert isinstance(self.scope._scoped_instances, dict)
+    
+    def test_resolve_singleton_from_parent(self):
+        """Test resolving singleton from parent container."""
+        self.container.register_singleton(MockService, MockService)
+        
+        service1 = self.scope.resolve(MockService)
+        service2 = self.scope.resolve(MockService)
+        
+        assert service1 is service2
+        assert isinstance(service1, MockService)
+    
+    def test_resolve_scoped_service(self):
+        """Test resolving scoped service within scope."""
+        self.container.register_scoped(MockService, MockService)
+        
+        service1 = self.scope.resolve(MockService)
+        service2 = self.scope.resolve(MockService)
+        
+        assert service1 is service2  # Same within scope
+        assert MockService in self.scope._scoped_instances
+    
+    def test_resolve_transient_service(self):
+        """Test resolving transient service."""
+        self.container.register_transient(MockService, MockService)
+        
+        service1 = self.scope.resolve(MockService)
+        service2 = self.scope.resolve(MockService)
+        
+        assert service1 is not service2  # Different instances
+    
+    def test_scope_cleanup(self):
+        """Test scope cleanup."""
+        self.container.register_scoped(MockService, MockService)
+        
+        service = self.scope.resolve(MockService)
+        assert MockService in self.scope._scoped_instances
+        
+        self.scope.cleanup()
+        
+        assert len(self.scope._scoped_instances) == 0
+        assert service.cleanup_called is True
+    
+    def test_scope_context_manager(self):
+        """Test scope as context manager."""
+        self.container.register_scoped(MockService, MockService)
+        
+        with self.container.create_scope() as scope:
+            service = scope.resolve(MockService)
+            assert isinstance(service, MockService)
+        
+        # Cleanup should have been called
+        assert service.cleanup_called is True
+
+
+class TestGlobalContainer:
+    """Test cases for global container functions."""
+    
+    def teardown_method(self):
+        """Clean up after tests."""
+        cleanup_container()
+    
+    def test_get_container_creates_global(self):
+        """Test getting global container creates it if not exists."""
+        container = get_container()
+        
+        assert isinstance(container, DependencyContainer)
+        
+        # Second call should return same instance
+        container2 = get_container()
+        assert container is container2
+    
+    def test_set_container(self):
+        """Test setting global container."""
+        custom_container = DependencyContainer()
+        set_container(custom_container)
+        
+        container = get_container()
+        assert container is custom_container
+    
+    def test_set_container_cleans_up_previous(self):
+        """Test setting container cleans up previous one."""
+        # Get initial container and register service
+        container1 = get_container()
+        container1.register_singleton(MockService, MockService)
+        service = container1.resolve(MockService)
+        
+        # Set new container
+        container2 = DependencyContainer()
+        set_container(container2)
+        
+        # Previous container should be cleaned up
+        assert service.cleanup_called is True
+        
+        # New container should be active
+        assert get_container() is container2
+    
+    def test_cleanup_container(self):
+        """Test cleaning up global container."""
+        container = get_container()
+        container.register_singleton(MockService, MockService)
+        service = container.resolve(MockService)
+        
+        cleanup_container()
+        
+        # Service should be cleaned up
+        assert service.cleanup_called is True
+        
+        # New container should be created on next get
+        new_container = get_container()
+        assert new_container is not container

tests/unit/infrastructure/factories/__init__.py

@@ -0,0 +1 @@
+"""Factory unit tests."""

tests/unit/infrastructure/factories/test_stt_provider_factory.py

@@ -0,0 +1,284 @@
+"""Unit tests for STTProviderFactory."""
+
+import pytest
+from unittest.mock import Mock, patch
+
+from src.infrastructure.stt.provider_factory import STTProviderFactory, ASRFactory
+from src.infrastructure.base.stt_provider_base import STTProviderBase
+from src.domain.exceptions import SpeechRecognitionException
+
+
+class MockSTTProvider(STTProviderBase):
+    """Mock STT provider for testing."""
+    
+    def __init__(self, provider_name="mock", available=True, models=None):
+        super().__init__(provider_name)
+        self._available = available
+        self._models = models or ["model1", "model2"]
+    
+    def _perform_transcription(self, audio_path, model):
+        return "Mock transcription"
+    
+    def is_available(self):
+        return self._available
+    
+    def get_available_models(self):
+        return self._models
+    
+    def get_default_model(self):
+        return self._models[0] if self._models else "default"
+
+
+class TestSTTProviderFactory:
+    """Test cases for STTProviderFactory."""
+    
+    def setup_method(self):
+        """Set up test fixtures."""
+        # Patch the providers registry for testing
+        self.original_providers = STTProviderFactory._providers.copy()
+        STTProviderFactory._providers = {'mock': MockSTTProvider}
+    
+    def teardown_method(self):
+        """Clean up after tests."""
+        STTProviderFactory._providers = self.original_providers
+    
+    def test_create_provider_success(self):
+        """Test successful provider creation."""
+        with patch.object(MockSTTProvider, 'is_available', return_value=True):
+            provider = STTProviderFactory.create_provider('mock')
+            
+            assert isinstance(provider, MockSTTProvider)
+            assert provider.provider_name == 'mock'
+    
+    def test_create_provider_case_insensitive(self):
+        """Test provider creation is case insensitive."""
+        with patch.object(MockSTTProvider, 'is_available', return_value=True):
+            provider = STTProviderFactory.create_provider('MOCK')
+            
+            assert isinstance(provider, MockSTTProvider)
+    
+    def test_create_provider_unknown(self):
+        """Test creating unknown provider raises exception."""
+        with pytest.raises(SpeechRecognitionException, match="Unknown STT provider: unknown"):
+            STTProviderFactory.create_provider('unknown')
+    
+    def test_create_provider_unavailable(self):
+        """Test creating unavailable provider raises exception."""
+        with patch.object(MockSTTProvider, 'is_available', return_value=False):
+            with pytest.raises(SpeechRecognitionException, match="STT provider mock is not available"):
+                STTProviderFactory.create_provider('mock')
+    
+    def test_create_provider_creation_error(self):
+        """Test handling provider creation errors."""
+        with patch.object(MockSTTProvider, '__init__', side_effect=Exception("Creation error")):
+            with pytest.raises(SpeechRecognitionException, match="Failed to create STT provider mock"):
+                STTProviderFactory.create_provider('mock')
+    
+    def test_create_provider_with_fallback_success(self):
+        """Test creating provider with fallback logic."""
+        STTProviderFactory._providers = {
+            'available': MockSTTProvider,
+            'unavailable': MockSTTProvider
+        }
+        
+        def mock_is_available(self):
+            return self.provider_name == 'available'
+        
+        with patch.object(MockSTTProvider, 'is_available', mock_is_available):
+            provider = STTProviderFactory.create_provider_with_fallback('unavailable')
+            assert provider.provider_name == 'available'
+    
+    def test_create_provider_with_fallback_preferred_works(self):
+        """Test fallback when preferred provider works."""
+        with patch.object(MockSTTProvider, 'is_available', return_value=True):
+            provider = STTProviderFactory.create_provider_with_fallback('mock')
+            assert provider.provider_name == 'mock'
+    
+    def test_create_provider_with_fallback_none_available(self):
+        """Test fallback when no providers are available."""
+        with patch.object(MockSTTProvider, 'is_available', return_value=False):
+            with pytest.raises(SpeechRecognitionException, match="No STT providers are available"):
+                STTProviderFactory.create_provider_with_fallback('mock')
+    
+    def test_create_provider_with_fallback_uses_fallback_order(self):
+        """Test that fallback uses the predefined fallback order."""
+        STTProviderFactory._providers = {
+            'whisper': MockSTTProvider,
+            'parakeet': MockSTTProvider
+        }
+        STTProviderFactory._fallback_order = ['whisper', 'parakeet']
+        
+        def mock_is_available(self):
+            return self.provider_name == 'parakeet'  # Only parakeet is available
+        
+        with patch.object(MockSTTProvider, 'is_available', mock_is_available):
+            provider = STTProviderFactory.create_provider_with_fallback('unavailable')
+            assert provider.provider_name == 'parakeet'
+    
+    def test_get_available_providers(self):
+        """Test getting list of available providers."""
+        STTProviderFactory._providers = {
+            'available1': MockSTTProvider,
+            'available2': MockSTTProvider,
+            'unavailable': MockSTTProvider
+        }
+        
+        def mock_is_available(self):
+            return self.provider_name in ['available1', 'available2']
+        
+        with patch.object(MockSTTProvider, 'is_available', mock_is_available):
+            available = STTProviderFactory.get_available_providers()
+            
+            assert 'available1' in available
+            assert 'available2' in available
+            assert 'unavailable' not in available
+    
+    def test_get_available_providers_error_handling(self):
+        """Test error handling when checking provider availability."""
+        def mock_init_error(self):
+            if self.provider_name == 'error':
+                raise Exception("Test error")
+            super(MockSTTProvider, self).__init__(self.provider_name)
+        
+        STTProviderFactory._providers = {
+            'good': MockSTTProvider,
+            'error': MockSTTProvider
+        }
+        
+        with patch.object(MockSTTProvider, '__init__', mock_init_error):
+            available = STTProviderFactory.get_available_providers()
+            
+            # Should handle error gracefully and not include error provider
+            assert 'error' not in available
+    
+    def test_get_provider_info_success(self):
+        """Test getting provider information."""
+        with patch.object(MockSTTProvider, 'is_available', return_value=True):
+            info = STTProviderFactory.get_provider_info('mock')
+            
+            assert info is not None
+            assert info['name'] == 'mock'
+            assert info['available'] is True
+            assert 'supported_languages' in info
+            assert 'available_models' in info
+            assert 'default_model' in info
+    
+    def test_get_provider_info_unavailable(self):
+        """Test getting info for unavailable provider."""
+        with patch.object(MockSTTProvider, 'is_available', return_value=False):
+            info = STTProviderFactory.get_provider_info('mock')
+            
+            assert info['available'] is False
+            assert info['available_models'] == []
+            assert info['default_model'] is None
+    
+    def test_get_provider_info_unknown(self):
+        """Test getting info for unknown provider."""
+        info = STTProviderFactory.get_provider_info('unknown')
+        assert info is None
+    
+    def test_get_provider_info_error(self):
+        """Test handling errors when getting provider info."""
+        with patch.object(MockSTTProvider, '__init__', side_effect=Exception("Test error")):
+            info = STTProviderFactory.get_provider_info('mock')
+            
+            assert info['available'] is False
+            assert info['error'] == 'Test error'
+    
+    def test_register_provider(self):
+        """Test registering a new provider."""
+        class NewProvider(STTProviderBase):
+            def _perform_transcription(self, audio_path, model):
+                return "New provider"
+            def is_available(self):
+                return True
+            def get_available_models(self):
+                return ["new_model"]
+            def get_default_model(self):
+                return "new_model"
+        
+        STTProviderFactory.register_provider('new', NewProvider)
+        
+        assert 'new' in STTProviderFactory._providers
+        assert STTProviderFactory._providers['new'] == NewProvider
+    
+    def test_register_provider_case_insensitive(self):
+        """Test provider registration is case insensitive."""
+        class NewProvider(STTProviderBase):
+            def _perform_transcription(self, audio_path, model):
+                return "New provider"
+            def is_available(self):
+                return True
+            def get_available_models(self):
+                return ["new_model"]
+            def get_default_model(self):
+                return "new_model"
+        
+        STTProviderFactory.register_provider('NEW', NewProvider)
+        
+        assert 'new' in STTProviderFactory._providers
+
+
+class TestASRFactory:
+    """Test cases for legacy ASRFactory."""
+    
+    def setup_method(self):
+        """Set up test fixtures."""
+        self.original_providers = STTProviderFactory._providers.copy()
+        STTProviderFactory._providers = {'mock': MockSTTProvider}
+    
+    def teardown_method(self):
+        """Clean up after tests."""
+        STTProviderFactory._providers = self.original_providers
+    
+    def test_get_model_default(self):
+        """Test getting model with default name."""
+        STTProviderFactory._providers = {'parakeet': MockSTTProvider}
+        
+        with patch.object(MockSTTProvider, 'is_available', return_value=True):
+            provider = ASRFactory.get_model()
+            assert provider.provider_name == 'parakeet'
+    
+    def test_get_model_specific(self):
+        """Test getting specific model."""
+        STTProviderFactory._providers = {'whisper': MockSTTProvider}
+        
+        with patch.object(MockSTTProvider, 'is_available', return_value=True):
+            provider = ASRFactory.get_model('whisper')
+            assert provider.provider_name == 'whisper'
+    
+    def test_get_model_legacy_mapping(self):
+        """Test legacy model name mapping."""
+        STTProviderFactory._providers = {'whisper': MockSTTProvider}
+        
+        with patch.object(MockSTTProvider, 'is_available', return_value=True):
+            # Test faster-whisper maps to whisper
+            provider = ASRFactory.get_model('faster-whisper')
+            assert provider.provider_name == 'whisper'
+    
+    def test_get_model_fallback(self):
+        """Test fallback when requested model is unavailable."""
+        STTProviderFactory._providers = {
+            'whisper': MockSTTProvider,
+            'parakeet': MockSTTProvider
+        }
+        
+        def mock_is_available(self):
+            return self.provider_name == 'parakeet'  # Only parakeet available
+        
+        with patch.object(MockSTTProvider, 'is_available', mock_is_available):
+            with patch.object(STTProviderFactory, 'create_provider_with_fallback') as mock_fallback:
+                mock_fallback.return_value = MockSTTProvider('parakeet')
+                
+                provider = ASRFactory.get_model('whisper')
+                mock_fallback.assert_called_once_with('whisper')
+    
+    def test_get_model_unknown_fallback(self):
+        """Test fallback for unknown model names."""
+        STTProviderFactory._providers = {'parakeet': MockSTTProvider}
+        
+        with patch.object(STTProviderFactory, 'create_provider_with_fallback') as mock_fallback:
+            mock_fallback.return_value = MockSTTProvider('parakeet')
+            
+            provider = ASRFactory.get_model('unknown_model')
+            mock_fallback.assert_called_once_with('unknown_model')

tests/unit/infrastructure/factories/test_translation_provider_factory.py

@@ -0,0 +1,346 @@
+"""Unit tests for TranslationProviderFactory."""
+
+import pytest
+from unittest.mock import Mock, patch
+from enum import Enum
+
+from src.infrastructure.translation.provider_factory import (
+    TranslationProviderFactory,
+    TranslationProviderType,
+    create_translation_provider,
+    get_default_translation_provider,
+    translation_provider_factory
+)
+from src.infrastructure.base.translation_provider_base import TranslationProviderBase
+from src.domain.exceptions import TranslationFailedException
+
+
+class MockTranslationProvider(TranslationProviderBase):
+    """Mock translation provider for testing."""
+    
+    def __init__(self, provider_name="mock", available=True, **kwargs):
+        super().__init__(provider_name)
+        self._available = available
+        self._config = kwargs
+    
+    def _translate_chunk(self, text, source_language, target_language):
+        return f"Translated: {text}"
+    
+    def is_available(self):
+        return self._available
+    
+    def get_supported_languages(self):
+        return {"en": ["es", "fr"], "es": ["en"]}
+
+
+class TestTranslationProviderFactory:
+    """Test cases for TranslationProviderFactory."""
+    
+    def setup_method(self):
+        """Set up test fixtures."""
+        self.factory = TranslationProviderFactory()
+        
+        # Patch the provider registry for testing
+        self.original_registry = TranslationProviderFactory._PROVIDER_REGISTRY.copy()
+        TranslationProviderFactory._PROVIDER_REGISTRY = {
+            TranslationProviderType.NLLB: MockTranslationProvider
+        }
+    
+    def teardown_method(self):
+        """Clean up after tests."""
+        TranslationProviderFactory._PROVIDER_REGISTRY = self.original_registry
+    
+    def test_factory_initialization(self):
+        """Test factory initialization."""
+        factory = TranslationProviderFactory()
+        
+        assert isinstance(factory._provider_cache, dict)
+        assert isinstance(factory._availability_cache, dict)
+        assert len(factory._provider_cache) == 0
+        assert len(factory._availability_cache) == 0
+    
+    def test_create_provider_success(self):
+        """Test successful provider creation."""
+        with patch.object(MockTranslationProvider, 'is_available', return_value=True):
+            provider = self.factory.create_provider(TranslationProviderType.NLLB)
+            
+            assert isinstance(provider, MockTranslationProvider)
+            assert provider.provider_name == 'mock'
+    
+    def test_create_provider_with_config(self):
+        """Test provider creation with custom config."""
+        config = {'model_name': 'custom_model', 'max_chunk_length': 500}
+        
+        with patch.object(MockTranslationProvider, 'is_available', return_value=True):
+            provider = self.factory.create_provider(TranslationProviderType.NLLB, config)
+            
+            assert isinstance(provider, MockTranslationProvider)
+            assert provider._config['model_name'] == 'custom_model'
+            assert provider._config['max_chunk_length'] == 500
+    
+    def test_create_provider_unknown_type(self):
+        """Test creating provider with unknown type."""
+        # Create a new enum value that's not in registry
+        class UnknownType(Enum):
+            UNKNOWN = "unknown"
+        
+        with pytest.raises(TranslationFailedException, match="Unknown translation provider type"):
+            self.factory.create_provider(UnknownType.UNKNOWN)
+    
+    def test_create_provider_creation_error(self):
+        """Test handling provider creation errors."""
+        with patch.object(MockTranslationProvider, '__init__', side_effect=Exception("Creation error")):
+            with pytest.raises(TranslationFailedException, match="Failed to create nllb provider"):
+                self.factory.create_provider(TranslationProviderType.NLLB)
+    
+    def test_create_provider_caching(self):
+        """Test provider instance caching."""
+        with patch.object(MockTranslationProvider, 'is_available', return_value=True):
+            provider1 = self.factory.create_provider(TranslationProviderType.NLLB, use_cache=True)
+            provider2 = self.factory.create_provider(TranslationProviderType.NLLB, use_cache=True)
+            
+            # Should return the same cached instance
+            assert provider1 is provider2
+    
+    def test_create_provider_no_caching(self):
+        """Test provider creation without caching."""
+        with patch.object(MockTranslationProvider, 'is_available', return_value=True):
+            provider1 = self.factory.create_provider(TranslationProviderType.NLLB, use_cache=False)
+            provider2 = self.factory.create_provider(TranslationProviderType.NLLB, use_cache=False)
+            
+            # Should return different instances
+            assert provider1 is not provider2
+    
+    def test_get_available_providers(self):
+        """Test getting available providers."""
+        with patch.object(MockTranslationProvider, 'is_available', return_value=True):
+            available = self.factory.get_available_providers()
+            
+            assert TranslationProviderType.NLLB in available
+    
+    def test_get_available_providers_unavailable(self):
+        """Test getting available providers when provider is unavailable."""
+        with patch.object(MockTranslationProvider, 'is_available', return_value=False):
+            available = self.factory.get_available_providers()
+            
+            assert TranslationProviderType.NLLB not in available
+    
+    def test_get_available_providers_force_check(self):
+        """Test forcing availability check ignores cache."""
+        with patch.object(MockTranslationProvider, 'is_available', return_value=True):
+            # First call caches result
+            available1 = self.factory.get_available_providers()
+            
+            # Change availability
+            with patch.object(MockTranslationProvider, 'is_available', return_value=False):
+                # Without force_check, should use cached result
+                available2 = self.factory.get_available_providers(force_check=False)
+                assert available1 == available2
+                
+                # With force_check, should get updated result
+                available3 = self.factory.get_available_providers(force_check=True)
+                assert available3 != available1
+    
+    def test_get_default_provider(self):
+        """Test getting default provider."""
+        with patch.object(MockTranslationProvider, 'is_available', return_value=True):
+            provider = self.factory.get_default_provider()
+            
+            assert isinstance(provider, MockTranslationProvider)
+    
+    def test_get_default_provider_no_available(self):
+        """Test getting default provider when none are available."""
+        with patch.object(MockTranslationProvider, 'is_available', return_value=False):
+            with pytest.raises(TranslationFailedException, match="No translation providers are available"):
+                self.factory.get_default_provider()
+    
+    def test_get_provider_with_fallback_preferred_available(self):
+        """Test fallback when preferred provider is available."""
+        preferred = [TranslationProviderType.NLLB]
+        
+        with patch.object(MockTranslationProvider, 'is_available', return_value=True):
+            provider = self.factory.get_provider_with_fallback(preferred)
+            
+            assert isinstance(provider, MockTranslationProvider)
+    
+    def test_get_provider_with_fallback_to_any_available(self):
+        """Test fallback to any available provider."""
+        # Create mock enum for testing
+        class TestType(Enum):
+            TEST = "test"
+        
+        preferred = [TestType.TEST]  # Not in registry
+        
+        with patch.object(MockTranslationProvider, 'is_available', return_value=True):
+            provider = self.factory.get_provider_with_fallback(preferred)
+            
+            # Should fallback to NLLB since it's available
+            assert isinstance(provider, MockTranslationProvider)
+    
+    def test_get_provider_with_fallback_none_available(self):
+        """Test fallback when no providers are available."""
+        preferred = [TranslationProviderType.NLLB]
+        
+        with patch.object(MockTranslationProvider, 'is_available', return_value=False):
+            with pytest.raises(TranslationFailedException, match="None of the preferred translation providers are available"):
+                self.factory.get_provider_with_fallback(preferred)
+    
+    def test_clear_cache(self):
+        """Test clearing provider cache."""
+        # Create cached provider
+        with patch.object(MockTranslationProvider, 'is_available', return_value=True):
+            self.factory.create_provider(TranslationProviderType.NLLB)
+            
+            assert len(self.factory._provider_cache) > 0
+            assert len(self.factory._availability_cache) > 0
+            
+            self.factory.clear_cache()
+            
+            assert len(self.factory._provider_cache) == 0
+            assert len(self.factory._availability_cache) == 0
+    
+    def test_get_provider_info(self):
+        """Test getting provider information."""
+        info = self.factory.get_provider_info(TranslationProviderType.NLLB)
+        
+        assert info['type'] == 'nllb'
+        assert info['class_name'] == 'MockTranslationProvider'
+        assert 'available' in info
+        assert 'default_config' in info
+        assert 'description' in info
+    
+    def test_get_provider_info_unknown_type(self):
+        """Test getting info for unknown provider type."""
+        class UnknownType(Enum):
+            UNKNOWN = "unknown"
+        
+        with pytest.raises(TranslationFailedException, match="Unknown provider type"):
+            self.factory.get_provider_info(UnknownType.UNKNOWN)
+    
+    def test_get_all_providers_info(self):
+        """Test getting information about all providers."""
+        info = self.factory.get_all_providers_info()
+        
+        assert 'nllb' in info
+        assert info['nllb']['type'] == 'nllb'
+        assert info['nllb']['class_name'] == 'MockTranslationProvider'
+    
+    def test_generate_cache_key(self):
+        """Test cache key generation."""
+        key1 = self.factory._generate_cache_key(TranslationProviderType.NLLB, None)
+        key2 = self.factory._generate_cache_key(TranslationProviderType.NLLB, {})
+        key3 = self.factory._generate_cache_key(TranslationProviderType.NLLB, {'a': 1, 'b': 2})
+        key4 = self.factory._generate_cache_key(TranslationProviderType.NLLB, {'b': 2, 'a': 1})
+        
+        assert key1 == key2  # None and empty dict should be same
+        assert key3 == key4  # Order shouldn't matter
+        assert key1 != key3  # Different configs should be different
+    
+    def test_register_provider(self):
+        """Test registering new provider type."""
+        class NewType(Enum):
+            NEW = "new"
+        
+        class NewProvider(TranslationProviderBase):
+            def _translate_chunk(self, text, source_language, target_language):
+                return f"New: {text}"
+            def is_available(self):
+                return True
+            def get_supported_languages(self):
+                return {}
+        
+        TranslationProviderFactory.register_provider(
+            NewType.NEW,
+            NewProvider,
+            {'default_config': 'value'}
+        )
+        
+        assert NewType.NEW in TranslationProviderFactory._PROVIDER_REGISTRY
+        assert TranslationProviderFactory._PROVIDER_REGISTRY[NewType.NEW] == NewProvider
+        assert TranslationProviderFactory._DEFAULT_CONFIGS[NewType.NEW] == {'default_config': 'value'}
+    
+    def test_get_supported_provider_types(self):
+        """Test getting supported provider types."""
+        types = TranslationProviderFactory.get_supported_provider_types()
+        
+        assert TranslationProviderType.NLLB in types
+        assert isinstance(types, list)
+    
+    def test_is_provider_available_caching(self):
+        """Test provider availability caching."""
+        with patch.object(MockTranslationProvider, 'is_available', return_value=True) as mock_available:
+            # First call should check availability
+            available1 = self.factory._is_provider_available(TranslationProviderType.NLLB)
+            
+            # Second call should use cache
+            available2 = self.factory._is_provider_available(TranslationProviderType.NLLB)
+            
+            assert available1 is True
+            assert available2 is True
+            # Should only be called once due to caching
+            assert mock_available.call_count == 1
+    
+    def test_is_provider_available_force_check(self):
+        """Test forcing provider availability check."""
+        with patch.object(MockTranslationProvider, 'is_available', return_value=True) as mock_available:
+            # First call
+            self.factory._is_provider_available(TranslationProviderType.NLLB)
+            
+            # Force check should ignore cache
+            self.factory._is_provider_available(TranslationProviderType.NLLB, force_check=True)
+            
+            # Should be called twice
+            assert mock_available.call_count == 2
+    
+    def test_is_provider_available_error_handling(self):
+        """Test error handling in availability check."""
+        with patch.object(MockTranslationProvider, '__init__', side_effect=Exception("Test error")):
+            available = self.factory._is_provider_available(TranslationProviderType.NLLB)
+            
+            assert available is False
+            # Should cache the error result
+            assert self.factory._availability_cache[TranslationProviderType.NLLB] is False
+
+
+class TestConvenienceFunctions:
+    """Test cases for convenience functions."""
+    
+    def setup_method(self):
+        """Set up test fixtures."""
+        # Patch the provider registry for testing
+        self.original_registry = TranslationProviderFactory._PROVIDER_REGISTRY.copy()
+        TranslationProviderFactory._PROVIDER_REGISTRY = {
+            TranslationProviderType.NLLB: MockTranslationProvider
+        }
+    
+    def teardown_method(self):
+        """Clean up after tests."""
+        TranslationProviderFactory._PROVIDER_REGISTRY = self.original_registry
+    
+    def test_create_translation_provider(self):
+        """Test convenience function for creating provider."""
+        with patch.object(MockTranslationProvider, 'is_available', return_value=True):
+            provider = create_translation_provider()
+            
+            assert isinstance(provider, MockTranslationProvider)
+    
+    def test_create_translation_provider_with_config(self):
+        """Test convenience function with config."""
+        config = {'test': 'value'}
+        
+        with patch.object(MockTranslationProvider, 'is_available', return_value=True):
+            provider = create_translation_provider(TranslationProviderType.NLLB, config)
+            
+            assert isinstance(provider, MockTranslationProvider)
+            assert provider._config['test'] == 'value'
+    
+    def test_get_default_translation_provider(self):
+        """Test convenience function for getting default provider."""
+        with patch.object(MockTranslationProvider, 'is_available', return_value=True):
+            provider = get_default_translation_provider()
+            
+            assert isinstance(provider, MockTranslationProvider)
+    
+    def test_global_factory_instance(self):
+        """Test global factory instance."""
+        assert isinstance(translation_provider_factory, TranslationProviderFactory)

tests/unit/infrastructure/factories/test_tts_provider_factory.py

@@ -0,0 +1,245 @@
+"""Unit tests for TTSProviderFactory."""
+
+import pytest
+from unittest.mock import Mock, patch, MagicMock
+
+from src.infrastructure.tts.provider_factory import TTSProviderFactory
+from src.infrastructure.base.tts_provider_base import TTSProviderBase
+from src.domain.exceptions import SpeechSynthesisException
+
+
+class MockTTSProvider(TTSProviderBase):
+    """Mock TTS provider for testing."""
+    
+    def __init__(self, provider_name="mock", available=True, voices=None):
+        super().__init__(provider_name)
+        self._available = available
+        self._voices = voices or ["voice1", "voice2"]
+    
+    def _generate_audio(self, request):
+        return b"mock_audio", 44100
+    
+    def _generate_audio_stream(self, request):
+        yield b"chunk1", 44100, False
+        yield b"chunk2", 44100, True
+    
+    def is_available(self):
+        return self._available
+    
+    def get_available_voices(self):
+        return self._voices
+
+
+class TestTTSProviderFactory:
+    """Test cases for TTSProviderFactory."""
+    
+    def setup_method(self):
+        """Set up test fixtures."""
+        self.factory = TTSProviderFactory()
+    
+    def test_factory_initialization(self):
+        """Test factory initialization."""
+        assert isinstance(self.factory._providers, dict)
+        assert isinstance(self.factory._provider_instances, dict)
+        assert 'dummy' in self.factory._providers
+    
+    @patch('src.infrastructure.tts.provider_factory.DummyTTSProvider')
+    def test_register_default_providers_dummy(self, mock_dummy):
+        """Test registration of dummy provider."""
+        factory = TTSProviderFactory()
+        
+        assert 'dummy' in factory._providers
+        assert factory._providers['dummy'] == mock_dummy
+    
+    @patch('src.infrastructure.tts.provider_factory.KokoroTTSProvider')
+    def test_register_default_providers_kokoro_available(self, mock_kokoro):
+        """Test registration of Kokoro provider when available."""
+        factory = TTSProviderFactory()
+        
+        assert 'kokoro' in factory._providers
+        assert factory._providers['kokoro'] == mock_kokoro
+    
+    @patch('src.infrastructure.tts.kokoro_provider.KokoroTTSProvider', side_effect=ImportError("Not available"))
+    def test_register_default_providers_kokoro_unavailable(self, mock_kokoro):
+        """Test handling when Kokoro provider is not available."""
+        factory = TTSProviderFactory()
+        
+        # Should not crash, just not register the provider
+        assert 'kokoro' not in factory._providers or factory._providers.get('kokoro') is None
+    
+    @patch.object(TTSProviderFactory, '_providers', {'mock': MockTTSProvider})
+    def test_get_available_providers(self):
+        """Test getting available providers."""
+        with patch.object(MockTTSProvider, 'is_available', return_value=True):
+            available = self.factory.get_available_providers()
+            assert 'mock' in available
+    
+    @patch.object(TTSProviderFactory, '_providers', {'mock': MockTTSProvider})
+    def test_get_available_providers_unavailable(self):
+        """Test getting available providers when provider is unavailable."""
+        with patch.object(MockTTSProvider, 'is_available', return_value=False):
+            available = self.factory.get_available_providers()
+            assert 'mock' not in available
+    
+    @patch.object(TTSProviderFactory, '_providers', {'mock': MockTTSProvider})
+    def test_get_available_providers_error(self):
+        """Test handling errors when checking provider availability."""
+        with patch.object(MockTTSProvider, '__init__', side_effect=Exception("Test error")):
+            available = self.factory.get_available_providers()
+            assert 'mock' not in available
+    
+    @patch.object(TTSProviderFactory, '_providers', {'mock': MockTTSProvider})
+    def test_create_provider_success(self):
+        """Test successful provider creation."""
+        with patch.object(MockTTSProvider, 'is_available', return_value=True):
+            provider = self.factory.create_provider('mock')
+            
+            assert isinstance(provider, MockTTSProvider)
+            assert provider.provider_name == 'mock'
+    
+    def test_create_provider_unknown(self):
+        """Test creating unknown provider raises exception."""
+        with pytest.raises(SpeechSynthesisException, match="Unknown TTS provider: unknown"):
+            self.factory.create_provider('unknown')
+    
+    @patch.object(TTSProviderFactory, '_providers', {'mock': MockTTSProvider})
+    def test_create_provider_unavailable(self):
+        """Test creating unavailable provider raises exception."""
+        with patch.object(MockTTSProvider, 'is_available', return_value=False):
+            with pytest.raises(SpeechSynthesisException, match="TTS provider mock is not available"):
+                self.factory.create_provider('mock')
+    
+    @patch.object(TTSProviderFactory, '_providers', {'mock': MockTTSProvider})
+    def test_create_provider_creation_error(self):
+        """Test handling provider creation errors."""
+        with patch.object(MockTTSProvider, '__init__', side_effect=Exception("Creation error")):
+            with pytest.raises(SpeechSynthesisException, match="Failed to create TTS provider mock"):
+                self.factory.create_provider('mock')
+    
+    @patch.object(TTSProviderFactory, '_providers', {'mock': MockTTSProvider})
+    def test_create_provider_with_lang_code(self):
+        """Test creating provider with language code."""
+        with patch.object(MockTTSProvider, 'is_available', return_value=True):
+            # Mock providers that accept lang_code
+            self.factory._providers['kokoro'] = MockTTSProvider
+            
+            provider = self.factory.create_provider('kokoro', lang_code='en')
+            assert isinstance(provider, MockTTSProvider)
+    
+    @patch.object(TTSProviderFactory, '_providers', {
+        'available1': MockTTSProvider,
+        'available2': MockTTSProvider,
+        'unavailable': MockTTSProvider
+    })
+    def test_get_provider_with_fallback_success(self):
+        """Test getting provider with fallback logic."""
+        def mock_is_available(self):
+            return self.provider_name in ['available1', 'available2']
+        
+        with patch.object(MockTTSProvider, 'is_available', mock_is_available):
+            provider = self.factory.get_provider_with_fallback(['unavailable', 'available1'])
+            assert provider.provider_name == 'available1'
+    
+    @patch.object(TTSProviderFactory, '_providers', {
+        'available': MockTTSProvider,
+        'unavailable': MockTTSProvider
+    })
+    def test_get_provider_with_fallback_to_any_available(self):
+        """Test fallback to any available provider."""
+        def mock_is_available(self):
+            return self.provider_name == 'available'
+        
+        with patch.object(MockTTSProvider, 'is_available', mock_is_available):
+            provider = self.factory.get_provider_with_fallback(['unavailable'])
+            assert provider.provider_name == 'available'
+    
+    @patch.object(TTSProviderFactory, '_providers', {'unavailable': MockTTSProvider})
+    def test_get_provider_with_fallback_none_available(self):
+        """Test fallback when no providers are available."""
+        with patch.object(MockTTSProvider, 'is_available', return_value=False):
+            with pytest.raises(SpeechSynthesisException, match="No TTS providers are available"):
+                self.factory.get_provider_with_fallback(['unavailable'])
+    
+    @patch.object(TTSProviderFactory, '_providers', {'mock': MockTTSProvider})
+    def test_get_provider_info_success(self):
+        """Test getting provider information."""
+        with patch.object(MockTTSProvider, 'is_available', return_value=True):
+            info = self.factory.get_provider_info('mock')
+            
+            assert info['available'] is True
+            assert info['name'] == 'mock'
+            assert 'supported_languages' in info
+            assert 'available_voices' in info
+    
+    @patch.object(TTSProviderFactory, '_providers', {'mock': MockTTSProvider})
+    def test_get_provider_info_unavailable(self):
+        """Test getting info for unavailable provider."""
+        with patch.object(MockTTSProvider, 'is_available', return_value=False):
+            info = self.factory.get_provider_info('mock')
+            
+            assert info['available'] is False
+            assert info['available_voices'] == []
+    
+    def test_get_provider_info_unknown(self):
+        """Test getting info for unknown provider."""
+        info = self.factory.get_provider_info('unknown')
+        
+        assert info['available'] is False
+        assert 'error' in info
+    
+    @patch.object(TTSProviderFactory, '_providers', {'mock': MockTTSProvider})
+    def test_get_provider_info_error(self):
+        """Test handling errors when getting provider info."""
+        with patch.object(MockTTSProvider, '__init__', side_effect=Exception("Test error")):
+            info = self.factory.get_provider_info('mock')
+            
+            assert info['available'] is False
+            assert info['error'] == 'Test error'
+    
+    def test_cleanup_providers(self):
+        """Test cleaning up provider instances."""
+        # Create mock provider with cleanup method
+        mock_provider = Mock()
+        mock_provider._cleanup_temp_files = Mock()
+        
+        self.factory._provider_instances['test'] = mock_provider
+        
+        self.factory.cleanup_providers()
+        
+        mock_provider._cleanup_temp_files.assert_called_once()
+        assert len(self.factory._provider_instances) == 0
+    
+    def test_cleanup_providers_no_cleanup_method(self):
+        """Test cleanup when provider has no cleanup method."""
+        mock_provider = Mock()
+        del mock_provider._cleanup_temp_files  # Remove cleanup method
+        
+        self.factory._provider_instances['test'] = mock_provider
+        
+        # Should not raise exception
+        self.factory.cleanup_providers()
+        assert len(self.factory._provider_instances) == 0
+    
+    def test_cleanup_providers_cleanup_error(self):
+        """Test handling cleanup errors."""
+        mock_provider = Mock()
+        mock_provider._cleanup_temp_files.side_effect = Exception("Cleanup error")
+        
+        self.factory._provider_instances['test'] = mock_provider
+        
+        # Should not raise exception
+        self.factory.cleanup_providers()
+        assert len(self.factory._provider_instances) == 0
+    
+    @patch.object(TTSProviderFactory, '_providers', {'mock': MockTTSProvider})
+    def test_provider_instance_caching(self):
+        """Test that provider instances are cached."""
+        with patch.object(MockTTSProvider, 'is_available', return_value=True):
+            # First call to get_available_providers should create instance
+            available1 = self.factory.get_available_providers()
+            
+            # Second call should use cached instance
+            available2 = self.factory.get_available_providers()
+            
+            assert available1 == available2
+            assert 'mock' in self.factory._provider_instances