Create integration tests for the complete pipeline

tests/integration/__init__.py

@@ -0,0 +1 @@
+# Integration tests package

tests/integration/test_audio_processing_pipeline.py

@@ -0,0 +1,452 @@
+"""Integration tests for the complete audio processing pipeline."""
+
+import os
+import tempfile
+import time
+import pytest
+from pathlib import Path
+from unittest.mock import Mock, patch, MagicMock
+from typing import Dict, Any, Optional
+
+from src.application.services.audio_processing_service import AudioProcessingApplicationService
+from src.application.dtos.audio_upload_dto import AudioUploadDto
+from src.application.dtos.processing_request_dto import ProcessingRequestDto
+from src.application.dtos.processing_result_dto import ProcessingResultDto
+from src.infrastructure.config.dependency_container import DependencyContainer
+from src.infrastructure.config.app_config import AppConfig
+from src.domain.models.audio_content import AudioContent
+from src.domain.models.text_content import TextContent
+from src.domain.models.voice_settings import VoiceSettings
+from src.domain.exceptions import (
+    SpeechRecognitionException,
+    TranslationFailedException,
+    SpeechSynthesisException
+)
+
+
+class TestAudioProcessingPipeline:
+    """Integration tests for the complete audio processing pipeline."""
+
+    @pytest.fixture
+    def temp_dir(self):
+        """Create temporary directory for test files."""
+        with tempfile.TemporaryDirectory() as temp_dir:
+            yield temp_dir
+
+    @pytest.fixture
+    def mock_config(self, temp_dir):
+        """Create mock configuration for testing."""
+        config = Mock(spec=AppConfig)
+        
+        # Processing configuration
+        config.get_processing_config.return_value = {
+            'max_file_size_mb': 50,
+            'supported_audio_formats': ['wav', 'mp3', 'flac'],
+            'temp_dir': temp_dir,
+            'cleanup_temp_files': True
+        }
+        
+        # Logging configuration
+        config.get_logging_config.return_value = {
+            'level': 'INFO',
+            'enable_file_logging': False,
+            'log_file_path': os.path.join(temp_dir, 'test.log'),
+            'format': '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+        }
+        
+        # STT configuration
+        config.get_stt_config.return_value = {
+            'preferred_providers': ['whisper-small', 'whisper-medium', 'parakeet']
+        }
+        
+        # TTS configuration
+        config.get_tts_config.return_value = {
+            'preferred_providers': ['kokoro', 'dia', 'cosyvoice2', 'dummy']
+        }
+        
+        return config
+
+    @pytest.fixture
+    def mock_container(self, mock_config):
+        """Create mock dependency container for testing."""
+        container = Mock(spec=DependencyContainer)
+        container.resolve.return_value = mock_config
+        
+        # Mock STT provider
+        mock_stt_provider = Mock()
+        mock_stt_provider.transcribe.return_value = TextContent(
+            text="Hello, this is a test transcription.",
+            language="en"
+        )
+        container.get_stt_provider.return_value = mock_stt_provider
+        
+        # Mock translation provider
+        mock_translation_provider = Mock()
+        mock_translation_provider.translate.return_value = TextContent(
+            text="Hola, esta es una transcripción de prueba.",
+            language="es"
+        )
+        container.get_translation_provider.return_value = mock_translation_provider
+        
+        # Mock TTS provider
+        mock_tts_provider = Mock()
+        mock_audio_content = AudioContent(
+            data=b"fake_audio_data",
+            format="wav",
+            sample_rate=22050,
+            duration=2.5
+        )
+        mock_tts_provider.synthesize.return_value = mock_audio_content
+        container.get_tts_provider.return_value = mock_tts_provider
+        
+        return container
+
+    @pytest.fixture
+    def audio_service(self, mock_container, mock_config):
+        """Create audio processing service for testing."""
+        return AudioProcessingApplicationService(mock_container, mock_config)
+
+    @pytest.fixture
+    def sample_audio_upload(self):
+        """Create sample audio upload DTO."""
+        return AudioUploadDto(
+            filename="test_audio.wav",
+            content=b"fake_wav_audio_data",
+            content_type="audio/wav",
+            size=1024
+        )
+
+    @pytest.fixture
+    def sample_processing_request(self, sample_audio_upload):
+        """Create sample processing request DTO."""
+        return ProcessingRequestDto(
+            audio=sample_audio_upload,
+            asr_model="whisper-small",
+            target_language="es",
+            source_language="en",
+            voice="kokoro",
+            speed=1.0,
+            requires_translation=True
+        )
+
+    def test_complete_pipeline_success(self, audio_service, sample_processing_request):
+        """Test successful execution of the complete audio processing pipeline."""
+        # Execute the pipeline
+        result = audio_service.process_audio_pipeline(sample_processing_request)
+        
+        # Verify successful result
+        assert isinstance(result, ProcessingResultDto)
+        assert result.success is True
+        assert result.error_message is None
+        assert result.original_text == "Hello, this is a test transcription."
+        assert result.translated_text == "Hola, esta es una transcripción de prueba."
+        assert result.audio_path is not None
+        assert result.processing_time > 0
+        assert result.metadata is not None
+        assert 'correlation_id' in result.metadata
+
+    def test_pipeline_without_translation(self, audio_service, sample_audio_upload):
+        """Test pipeline execution without translation (same language)."""
+        request = ProcessingRequestDto(
+            audio=sample_audio_upload,
+            asr_model="whisper-small",
+            target_language="en",
+            source_language="en",
+            voice="kokoro",
+            speed=1.0,
+            requires_translation=False
+        )
+        
+        result = audio_service.process_audio_pipeline(request)
+        
+        assert result.success is True
+        assert result.original_text == "Hello, this is a test transcription."
+        assert result.translated_text is None  # No translation performed
+        assert result.audio_path is not None
+
+    def test_pipeline_with_different_voice_settings(self, audio_service, sample_audio_upload):
+        """Test pipeline with different voice settings."""
+        request = ProcessingRequestDto(
+            audio=sample_audio_upload,
+            asr_model="whisper-medium",
+            target_language="fr",
+            source_language="en",
+            voice="dia",
+            speed=1.5,
+            requires_translation=True
+        )
+        
+        result = audio_service.process_audio_pipeline(request)
+        
+        assert result.success is True
+        assert result.metadata['voice'] == "dia"
+        assert result.metadata['speed'] == 1.5
+        assert result.metadata['asr_model'] == "whisper-medium"
+
+    def test_pipeline_performance_metrics(self, audio_service, sample_processing_request):
+        """Test that pipeline captures performance metrics."""
+        start_time = time.time()
+        result = audio_service.process_audio_pipeline(sample_processing_request)
+        end_time = time.time()
+        
+        assert result.success is True
+        assert result.processing_time > 0
+        assert result.processing_time <= (end_time - start_time) + 0.1  # Allow small margin
+        assert 'correlation_id' in result.metadata
+
+    def test_pipeline_with_large_file(self, audio_service, mock_config):
+        """Test pipeline behavior with large audio files."""
+        # Create large audio upload
+        large_audio = AudioUploadDto(
+            filename="large_audio.wav",
+            content=b"x" * (10 * 1024 * 1024),  # 10MB
+            content_type="audio/wav",
+            size=10 * 1024 * 1024
+        )
+        
+        request = ProcessingRequestDto(
+            audio=large_audio,
+            asr_model="whisper-small",
+            target_language="es",
+            voice="kokoro",
+            speed=1.0,
+            requires_translation=True
+        )
+        
+        result = audio_service.process_audio_pipeline(request)
+        
+        assert result.success is True
+        assert result.metadata['file_size'] == 10 * 1024 * 1024
+
+    def test_pipeline_file_cleanup(self, audio_service, sample_processing_request, temp_dir):
+        """Test that temporary files are properly cleaned up."""
+        # Count files before processing
+        files_before = len(list(Path(temp_dir).rglob("*")))
+        
+        result = audio_service.process_audio_pipeline(sample_processing_request)
+        
+        # Verify processing succeeded
+        assert result.success is True
+        
+        # Verify cleanup occurred (no additional temp files)
+        files_after = len(list(Path(temp_dir).rglob("*")))
+        assert files_after <= files_before + 1  # Allow for output file
+
+    def test_pipeline_correlation_id_tracking(self, audio_service, sample_processing_request):
+        """Test that correlation IDs are properly tracked throughout the pipeline."""
+        result = audio_service.process_audio_pipeline(sample_processing_request)
+        
+        assert result.success is True
+        assert 'correlation_id' in result.metadata
+        
+        correlation_id = result.metadata['correlation_id']
+        assert isinstance(correlation_id, str)
+        assert len(correlation_id) > 0
+        
+        # Verify correlation ID is used in status tracking
+        status = audio_service.get_processing_status(correlation_id)
+        assert status['correlation_id'] == correlation_id
+
+    def test_pipeline_metadata_completeness(self, audio_service, sample_processing_request):
+        """Test that pipeline result contains complete metadata."""
+        result = audio_service.process_audio_pipeline(sample_processing_request)
+        
+        assert result.success is True
+        assert result.metadata is not None
+        
+        expected_metadata_keys = [
+            'correlation_id', 'asr_model', 'target_language', 
+            'voice', 'speed', 'translation_required'
+        ]
+        
+        for key in expected_metadata_keys:
+            assert key in result.metadata
+
+    def test_pipeline_supported_configurations(self, audio_service):
+        """Test retrieval of supported pipeline configurations."""
+        config = audio_service.get_supported_configurations()
+        
+        assert 'asr_models' in config
+        assert 'voices' in config
+        assert 'languages' in config
+        assert 'audio_formats' in config
+        assert 'max_file_size_mb' in config
+        assert 'speed_range' in config
+        
+        assert isinstance(config['asr_models'], list)
+        assert isinstance(config['voices'], list)
+        assert isinstance(config['languages'], list)
+        assert len(config['asr_models']) > 0
+        assert len(config['voices']) > 0
+
+    def test_pipeline_context_manager(self, mock_container, mock_config):
+        """Test audio service as context manager."""
+        with AudioProcessingApplicationService(mock_container, mock_config) as service:
+            assert service is not None
+            
+            # Service should be usable within context
+            config = service.get_supported_configurations()
+            assert config is not None
+
+    def test_pipeline_multiple_requests(self, audio_service, sample_audio_upload):
+        """Test processing multiple requests in sequence."""
+        requests = []
+        for i in range(3):
+            request = ProcessingRequestDto(
+                audio=sample_audio_upload,
+                asr_model="whisper-small",
+                target_language="es",
+                voice="kokoro",
+                speed=1.0,
+                requires_translation=True
+            )
+            requests.append(request)
+        
+        results = []
+        for request in requests:
+            result = audio_service.process_audio_pipeline(request)
+            results.append(result)
+        
+        # Verify all requests succeeded
+        for result in results:
+            assert result.success is True
+            assert result.original_text is not None
+            assert result.translated_text is not None
+        
+        # Verify each request has unique correlation ID
+        correlation_ids = [r.metadata['correlation_id'] for r in results]
+        assert len(set(correlation_ids)) == 3  # All unique
+
+    def test_pipeline_concurrent_processing(self, audio_service, sample_processing_request):
+        """Test pipeline behavior under concurrent processing."""
+        import threading
+        import queue
+        
+        results_queue = queue.Queue()
+        
+        def process_request():
+            try:
+                result = audio_service.process_audio_pipeline(sample_processing_request)
+                results_queue.put(result)
+            except Exception as e:
+                results_queue.put(e)
+        
+        # Start multiple threads
+        threads = []
+        for _ in range(3):
+            thread = threading.Thread(target=process_request)
+            threads.append(thread)
+            thread.start()
+        
+        # Wait for completion
+        for thread in threads:
+            thread.join()
+        
+        # Verify all results
+        results = []
+        while not results_queue.empty():
+            result = results_queue.get()
+            if isinstance(result, Exception):
+                pytest.fail(f"Concurrent processing failed: {result}")
+            results.append(result)
+        
+        assert len(results) == 3
+        for result in results:
+            assert result.success is True
+
+    def test_pipeline_memory_usage(self, audio_service, sample_processing_request):
+        """Test pipeline memory usage and cleanup."""
+        import psutil
+        import os
+        
+        process = psutil.Process(os.getpid())
+        memory_before = process.memory_info().rss
+        
+        # Process multiple requests
+        for _ in range(5):
+            result = audio_service.process_audio_pipeline(sample_processing_request)
+            assert result.success is True
+        
+        memory_after = process.memory_info().rss
+        memory_increase = memory_after - memory_before
+        
+        # Memory increase should be reasonable (less than 50MB for test data)
+        assert memory_increase < 50 * 1024 * 1024
+
+    def test_pipeline_with_streaming_synthesis(self, audio_service, sample_processing_request, mock_container):
+        """Test pipeline with streaming TTS synthesis."""
+        # Mock streaming TTS provider
+        mock_tts_provider = mock_container.get_tts_provider.return_value
+        
+        def mock_stream():
+            for i in range(3):
+                yield AudioContent(
+                    data=f"chunk_{i}".encode(),
+                    format="wav",
+                    sample_rate=22050,
+                    duration=0.5
+                )
+        
+        mock_tts_provider.synthesize_stream.return_value = mock_stream()
+        
+        result = audio_service.process_audio_pipeline(sample_processing_request)
+        
+        assert result.success is True
+        assert result.audio_path is not None
+
+    def test_pipeline_configuration_validation(self, audio_service):
+        """Test pipeline configuration validation."""
+        config = audio_service.get_supported_configurations()
+        
+        # Verify configuration structure
+        assert isinstance(config['asr_models'], list)
+        assert isinstance(config['voices'], list)
+        assert isinstance(config['languages'], list)
+        assert isinstance(config['audio_formats'], list)
+        assert isinstance(config['max_file_size_mb'], (int, float))
+        assert isinstance(config['speed_range'], dict)
+        
+        # Verify speed range
+        speed_range = config['speed_range']
+        assert 'min' in speed_range
+        assert 'max' in speed_range
+        assert speed_range['min'] < speed_range['max']
+        assert speed_range['min'] > 0
+        assert speed_range['max'] <= 3.0
+
+    def test_pipeline_error_recovery_logging(self, audio_service, sample_processing_request, mock_container):
+        """Test that error recovery attempts are properly logged."""
+        # Mock STT provider to fail first time, succeed second time
+        mock_stt_provider = mock_container.get_stt_provider.return_value
+        mock_stt_provider.transcribe.side_effect = [
+            SpeechRecognitionException("First attempt failed"),
+            TextContent(text="Recovered transcription", language="en")
+        ]
+        
+        with patch('src.application.services.audio_processing_service.logger') as mock_logger:
+            result = audio_service.process_audio_pipeline(sample_processing_request)
+            
+            assert result.success is True
+            # Verify error and recovery were logged
+            mock_logger.warning.assert_called()
+            mock_logger.info.assert_called()
+
+    def test_pipeline_end_to_end_timing(self, audio_service, sample_processing_request):
+        """Test end-to-end pipeline timing and performance."""
+        start_time = time.time()
+        result = audio_service.process_audio_pipeline(sample_processing_request)
+        end_time = time.time()
+        
+        total_time = end_time - start_time
+        
+        assert result.success is True
+        assert result.processing_time > 0
+        assert result.processing_time <= total_time
+        
+        # For mock providers, processing should be fast
+        assert total_time < 5.0  # Should complete within 5 seconds
+        
+        # Verify timing metadata
+        assert 'correlation_id' in result.metadata
+        timing_info = result.metadata
+        assert timing_info is not None

tests/integration/test_file_handling.py

@@ -0,0 +1,580 @@
+"""Integration tests for file handling and cleanup."""
+
+import os
+import tempfile
+import shutil
+import time
+import pytest
+from pathlib import Path
+from unittest.mock import Mock, patch, MagicMock
+from typing import List, Dict, Any
+
+from src.application.services.audio_processing_service import AudioProcessingApplicationService
+from src.application.dtos.audio_upload_dto import AudioUploadDto
+from src.application.dtos.processing_request_dto import ProcessingRequestDto
+from src.infrastructure.config.dependency_container import DependencyContainer
+from src.infrastructure.config.app_config import AppConfig
+from src.domain.models.audio_content import AudioContent
+from src.domain.models.text_content import TextContent
+
+
+class TestFileHandling:
+    """Integration tests for file handling and cleanup."""
+
+    @pytest.fixture
+    def temp_base_dir(self):
+        """Create base temporary directory for all tests."""
+        with tempfile.TemporaryDirectory() as temp_dir:
+            yield temp_dir
+
+    @pytest.fixture
+    def mock_config(self, temp_base_dir):
+        """Create mock configuration with temporary directories."""
+        config = Mock(spec=AppConfig)
+        
+        # Processing configuration with temp directory
+        config.get_processing_config.return_value = {
+            'max_file_size_mb': 50,
+            'supported_audio_formats': ['wav', 'mp3', 'flac', 'ogg'],
+            'temp_dir': temp_base_dir,
+            'cleanup_temp_files': True,
+            'max_temp_file_age_hours': 24,
+            'temp_file_prefix': 'audio_processing_'
+        }
+        
+        # Logging configuration
+        config.get_logging_config.return_value = {
+            'level': 'INFO',
+            'enable_file_logging': True,
+            'log_file_path': os.path.join(temp_base_dir, 'processing.log'),
+            'format': '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+        }
+        
+        # STT configuration
+        config.get_stt_config.return_value = {
+            'preferred_providers': ['whisper-small']
+        }
+        
+        # TTS configuration
+        config.get_tts_config.return_value = {
+            'preferred_providers': ['dummy']
+        }
+        
+        return config
+
+    @pytest.fixture
+    def mock_container(self, mock_config):
+        """Create mock dependency container."""
+        container = Mock(spec=DependencyContainer)
+        container.resolve.return_value = mock_config
+        
+        # Mock providers
+        mock_stt_provider = Mock()
+        mock_stt_provider.transcribe.return_value = TextContent(
+            text="Test transcription",
+            language="en"
+        )
+        container.get_stt_provider.return_value = mock_stt_provider
+        
+        mock_translation_provider = Mock()
+        mock_translation_provider.translate.return_value = TextContent(
+            text="Prueba de transcripción",
+            language="es"
+        )
+        container.get_translation_provider.return_value = mock_translation_provider
+        
+        mock_tts_provider = Mock()
+        mock_tts_provider.synthesize.return_value = AudioContent(
+            data=b"synthesized_audio_data",
+            format="wav",
+            sample_rate=22050,
+            duration=2.0
+        )
+        container.get_tts_provider.return_value = mock_tts_provider
+        
+        return container
+
+    @pytest.fixture
+    def audio_service(self, mock_container, mock_config):
+        """Create audio processing service."""
+        return AudioProcessingApplicationService(mock_container, mock_config)
+
+    @pytest.fixture
+    def sample_audio_files(self, temp_base_dir):
+        """Create sample audio files for testing."""
+        files = {}
+        
+        # Create different audio file types
+        audio_formats = {
+            'wav': b'RIFF\x24\x00\x00\x00WAVEfmt \x10\x00\x00\x00',
+            'mp3': b'\xff\xfb\x90\x00\x00\x00\x00\x00\x00\x00\x00\x00',
+            'flac': b'fLaC\x00\x00\x00\x22\x10\x00\x10\x00',
+            'ogg': b'OggS\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00'
+        }
+        
+        for format_name, header in audio_formats.items():
+            file_path = os.path.join(temp_base_dir, f'test_audio.{format_name}')
+            with open(file_path, 'wb') as f:
+                f.write(header + b'\x00' * 1000)  # Add some padding
+            files[format_name] = file_path
+        
+        yield files
+        
+        # Cleanup
+        for file_path in files.values():
+            if os.path.exists(file_path):
+                os.remove(file_path)
+
+    def test_temp_directory_creation(self, audio_service, temp_base_dir):
+        """Test temporary directory creation and structure."""
+        # Create a processing request to trigger temp directory creation
+        audio_upload = AudioUploadDto(
+            filename="test.wav",
+            content=b"fake_audio_data",
+            content_type="audio/wav",
+            size=len(b"fake_audio_data")
+        )
+        
+        request = ProcessingRequestDto(
+            audio=audio_upload,
+            asr_model="whisper-small",
+            target_language="es",
+            voice="dummy",
+            speed=1.0,
+            requires_translation=True
+        )
+        
+        # Process and check temp directory creation
+        result = audio_service.process_audio_pipeline(request)
+        
+        assert result.success is True
+        
+        # Verify base temp directory exists
+        assert os.path.exists(temp_base_dir)
+        assert os.path.isdir(temp_base_dir)
+
+    def test_input_file_handling(self, audio_service, sample_audio_files):
+        """Test handling of different input audio file formats."""
+        for format_name, file_path in sample_audio_files.items():
+            with open(file_path, 'rb') as f:
+                content = f.read()
+            
+            audio_upload = AudioUploadDto(
+                filename=f"test.{format_name}",
+                content=content,
+                content_type=f"audio/{format_name}",
+                size=len(content)
+            )
+            
+            request = ProcessingRequestDto(
+                audio=audio_upload,
+                asr_model="whisper-small",
+                target_language="en",
+                voice="dummy",
+                speed=1.0,
+                requires_translation=False
+            )
+            
+            result = audio_service.process_audio_pipeline(request)
+            
+            assert result.success is True, f"Failed to process {format_name} file"
+            assert result.audio_path is not None
+            assert os.path.exists(result.audio_path)
+
+    def test_output_file_generation(self, audio_service, temp_base_dir):
+        """Test output audio file generation."""
+        audio_upload = AudioUploadDto(
+            filename="input.wav",
+            content=b"input_audio_data",
+            content_type="audio/wav",
+            size=len(b"input_audio_data")
+        )
+        
+        request = ProcessingRequestDto(
+            audio=audio_upload,
+            asr_model="whisper-small",
+            target_language="es",
+            voice="dummy",
+            speed=1.0,
+            requires_translation=True
+        )
+        
+        result = audio_service.process_audio_pipeline(request)
+        
+        assert result.success is True
+        assert result.audio_path is not None
+        
+        # Verify output file exists and has content
+        assert os.path.exists(result.audio_path)
+        assert os.path.getsize(result.audio_path) > 0
+        
+        # Verify file is in expected location
+        assert temp_base_dir in result.audio_path
+
+    def test_temp_file_cleanup_success(self, audio_service, temp_base_dir):
+        """Test temporary file cleanup after successful processing."""
+        initial_files = set(os.listdir(temp_base_dir))
+        
+        audio_upload = AudioUploadDto(
+            filename="cleanup_test.wav",
+            content=b"cleanup_test_data",
+            content_type="audio/wav",
+            size=len(b"cleanup_test_data")
+        )
+        
+        request = ProcessingRequestDto(
+            audio=audio_upload,
+            asr_model="whisper-small",
+            target_language="es",
+            voice="dummy",
+            speed=1.0,
+            requires_translation=True
+        )
+        
+        result = audio_service.process_audio_pipeline(request)
+        
+        assert result.success is True
+        
+        # Check that temporary processing files are cleaned up
+        # (output file should remain)
+        final_files = set(os.listdir(temp_base_dir))
+        new_files = final_files - initial_files
+        
+        # Should only have the output file and possibly log files
+        assert len(new_files) <= 2  # output file + possible log file
+
+    def test_temp_file_cleanup_on_error(self, audio_service, temp_base_dir, mock_container):
+        """Test temporary file cleanup when processing fails."""
+        # Mock STT provider to fail
+        mock_stt_provider = mock_container.get_stt_provider.return_value
+        mock_stt_provider.transcribe.side_effect = Exception("STT failed")
+        
+        initial_files = set(os.listdir(temp_base_dir))
+        
+        audio_upload = AudioUploadDto(
+            filename="error_test.wav",
+            content=b"error_test_data",
+            content_type="audio/wav",
+            size=len(b"error_test_data")
+        )
+        
+        request = ProcessingRequestDto(
+            audio=audio_upload,
+            asr_model="whisper-small",
+            target_language="es",
+            voice="dummy",
+            speed=1.0,
+            requires_translation=True
+        )
+        
+        result = audio_service.process_audio_pipeline(request)
+        
+        assert result.success is False
+        
+        # Verify cleanup occurred even on error
+        final_files = set(os.listdir(temp_base_dir))
+        new_files = final_files - initial_files
+        
+        # Should have minimal new files (possibly just log files)
+        assert len(new_files) <= 1
+
+    def test_large_file_handling(self, audio_service, temp_base_dir):
+        """Test handling of large audio files."""
+        # Create large audio content (5MB)
+        large_content = b"x" * (5 * 1024 * 1024)
+        
+        audio_upload = AudioUploadDto(
+            filename="large_file.wav",
+            content=large_content,
+            content_type="audio/wav",
+            size=len(large_content)
+        )
+        
+        request = ProcessingRequestDto(
+            audio=audio_upload,
+            asr_model="whisper-small",
+            target_language="es",
+            voice="dummy",
+            speed=1.0,
+            requires_translation=True
+        )
+        
+        result = audio_service.process_audio_pipeline(request)
+        
+        assert result.success is True
+        assert result.audio_path is not None
+        assert os.path.exists(result.audio_path)
+
+    def test_concurrent_file_handling(self, audio_service, temp_base_dir):
+        """Test concurrent file handling and cleanup."""
+        import threading
+        import queue
+        
+        results_queue = queue.Queue()
+        
+        def process_file(file_id):
+            try:
+                audio_upload = AudioUploadDto(
+                    filename=f"concurrent_{file_id}.wav",
+                    content=f"concurrent_data_{file_id}".encode(),
+                    content_type="audio/wav",
+                    size=len(f"concurrent_data_{file_id}".encode())
+                )
+                
+                request = ProcessingRequestDto(
+                    audio=audio_upload,
+                    asr_model="whisper-small",
+                    target_language="es",
+                    voice="dummy",
+                    speed=1.0,
+                    requires_translation=True
+                )
+                
+                result = audio_service.process_audio_pipeline(request)
+                results_queue.put((file_id, result))
+            except Exception as e:
+                results_queue.put((file_id, e))
+        
+        # Start multiple threads
+        threads = []
+        for i in range(3):
+            thread = threading.Thread(target=process_file, args=(i,))
+            threads.append(thread)
+            thread.start()
+        
+        # Wait for completion
+        for thread in threads:
+            thread.join()
+        
+        # Verify results
+        results = {}
+        while not results_queue.empty():
+            file_id, result = results_queue.get()
+            if isinstance(result, Exception):
+                pytest.fail(f"Concurrent processing failed for file {file_id}: {result}")
+            results[file_id] = result
+        
+        assert len(results) == 3
+        for file_id, result in results.items():
+            assert result.success is True
+            assert result.audio_path is not None
+            assert os.path.exists(result.audio_path)
+
+    def test_file_permission_handling(self, audio_service, temp_base_dir):
+        """Test file permission handling."""
+        audio_upload = AudioUploadDto(
+            filename="permission_test.wav",
+            content=b"permission_test_data",
+            content_type="audio/wav",
+            size=len(b"permission_test_data")
+        )
+        
+        request = ProcessingRequestDto(
+            audio=audio_upload,
+            asr_model="whisper-small",
+            target_language="es",
+            voice="dummy",
+            speed=1.0,
+            requires_translation=True
+        )
+        
+        result = audio_service.process_audio_pipeline(request)
+        
+        assert result.success is True
+        assert result.audio_path is not None
+        
+        # Verify file permissions
+        file_stat = os.stat(result.audio_path)
+        assert file_stat.st_mode & 0o600  # At least owner read/write
+
+    def test_disk_space_monitoring(self, audio_service, temp_base_dir):
+        """Test disk space monitoring during processing."""
+        import shutil
+        
+        # Get initial disk space
+        initial_space = shutil.disk_usage(temp_base_dir)
+        
+        audio_upload = AudioUploadDto(
+            filename="space_test.wav",
+            content=b"space_test_data" * 1000,  # Larger content
+            content_type="audio/wav",
+            size=len(b"space_test_data" * 1000)
+        )
+        
+        request = ProcessingRequestDto(
+            audio=audio_upload,
+            asr_model="whisper-small",
+            target_language="es",
+            voice="dummy",
+            speed=1.0,
+            requires_translation=True
+        )
+        
+        result = audio_service.process_audio_pipeline(request)
+        
+        assert result.success is True
+        
+        # Verify disk space hasn't been exhausted
+        final_space = shutil.disk_usage(temp_base_dir)
+        assert final_space.free > 0
+
+    def test_file_naming_conventions(self, audio_service, temp_base_dir):
+        """Test file naming conventions and uniqueness."""
+        results = []
+        
+        # Process multiple files to test naming
+        for i in range(3):
+            audio_upload = AudioUploadDto(
+                filename=f"naming_test_{i}.wav",
+                content=f"naming_test_data_{i}".encode(),
+                content_type="audio/wav",
+                size=len(f"naming_test_data_{i}".encode())
+            )
+            
+            request = ProcessingRequestDto(
+                audio=audio_upload,
+                asr_model="whisper-small",
+                target_language="es",
+                voice="dummy",
+                speed=1.0,
+                requires_translation=True
+            )
+            
+            result = audio_service.process_audio_pipeline(request)
+            results.append(result)
+        
+        # Verify all results are successful
+        for result in results:
+            assert result.success is True
+            assert result.audio_path is not None
+        
+        # Verify unique file names
+        output_paths = [r.audio_path for r in results]
+        assert len(set(output_paths)) == len(output_paths)  # All unique
+        
+        # Verify naming convention
+        for path in output_paths:
+            filename = os.path.basename(path)
+            assert filename.startswith("output_")
+            assert filename.endswith(".wav")
+
+    def test_file_encoding_handling(self, audio_service, temp_base_dir):
+        """Test handling of different file encodings and special characters."""
+        # Test with filename containing special characters
+        special_filename = "test_file_ñáéíóú_测试.wav"
+        
+        audio_upload = AudioUploadDto(
+            filename=special_filename,
+            content=b"encoding_test_data",
+            content_type="audio/wav",
+            size=len(b"encoding_test_data")
+        )
+        
+        request = ProcessingRequestDto(
+            audio=audio_upload,
+            asr_model="whisper-small",
+            target_language="es",
+            voice="dummy",
+            speed=1.0,
+            requires_translation=True
+        )
+        
+        result = audio_service.process_audio_pipeline(request)
+        
+        assert result.success is True
+        assert result.audio_path is not None
+        assert os.path.exists(result.audio_path)
+
+    def test_file_cleanup_context_manager(self, mock_container, mock_config, temp_base_dir):
+        """Test file cleanup using context manager."""
+        initial_files = set(os.listdir(temp_base_dir))
+        
+        with AudioProcessingApplicationService(mock_container, mock_config) as service:
+            audio_upload = AudioUploadDto(
+                filename="context_test.wav",
+                content=b"context_test_data",
+                content_type="audio/wav",
+                size=len(b"context_test_data")
+            )
+            
+            request = ProcessingRequestDto(
+                audio=audio_upload,
+                asr_model="whisper-small",
+                target_language="es",
+                voice="dummy",
+                speed=1.0,
+                requires_translation=True
+            )
+            
+            result = service.process_audio_pipeline(request)
+            assert result.success is True
+        
+        # Verify cleanup occurred when exiting context
+        final_files = set(os.listdir(temp_base_dir))
+        new_files = final_files - initial_files
+        
+        # Should have minimal new files after context exit
+        assert len(new_files) <= 1  # Possibly just log file
+
+    def test_file_recovery_after_interruption(self, audio_service, temp_base_dir, mock_container):
+        """Test file recovery mechanisms after processing interruption."""
+        # Mock provider to simulate interruption
+        mock_tts_provider = mock_container.get_tts_provider.return_value
+        mock_tts_provider.synthesize.side_effect = KeyboardInterrupt("Simulated interruption")
+        
+        audio_upload = AudioUploadDto(
+            filename="interruption_test.wav",
+            content=b"interruption_test_data",
+            content_type="audio/wav",
+            size=len(b"interruption_test_data")
+        )
+        
+        request = ProcessingRequestDto(
+            audio=audio_upload,
+            asr_model="whisper-small",
+            target_language="es",
+            voice="dummy",
+            speed=1.0,
+            requires_translation=True
+        )
+        
+        # Process should handle interruption gracefully
+        with pytest.raises(KeyboardInterrupt):
+            audio_service.process_audio_pipeline(request)
+        
+        # Verify cleanup still occurred
+        # (In real implementation, this would be handled by signal handlers)
+
+    def test_file_metadata_preservation(self, audio_service, temp_base_dir):
+        """Test preservation of file metadata during processing."""
+        original_filename = "metadata_test.wav"
+        original_content = b"metadata_test_data"
+        
+        audio_upload = AudioUploadDto(
+            filename=original_filename,
+            content=original_content,
+            content_type="audio/wav",
+            size=len(original_content)
+        )
+        
+        request = ProcessingRequestDto(
+            audio=audio_upload,
+            asr_model="whisper-small",
+            target_language="es",
+            voice="dummy",
+            speed=1.0,
+            requires_translation=True
+        )
+        
+        result = audio_service.process_audio_pipeline(request)
+        
+        assert result.success is True
+        assert result.metadata is not None
+        
+        # Verify original filename is preserved in metadata
+        correlation_id = result.metadata.get('correlation_id')
+        assert correlation_id is not None
+        
+        # Verify output file exists
+        assert result.audio_path is not None
+        assert os.path.exists(result.audio_path)

tests/integration/test_performance_and_errors.py

@@ -0,0 +1,550 @@
+"""Integration tests for performance and error scenario testing."""
+
+import time
+import pytest
+import threading
+import queue
+import psutil
+import os
+from unittest.mock import Mock, patch, MagicMock
+from typing import List, Dict, Any, Optional
+
+from src.application.services.audio_processing_service import AudioProcessingApplicationService
+from src.application.dtos.audio_upload_dto import AudioUploadDto
+from src.application.dtos.processing_request_dto import ProcessingRequestDto
+from src.application.dtos.processing_result_dto import ProcessingResultDto
+from src.infrastructure.config.dependency_container import DependencyContainer
+from src.infrastructure.config.app_config import AppConfig
+from src.domain.models.audio_content import AudioContent
+from src.domain.models.text_content import TextContent
+from src.domain.exceptions import (
+    SpeechRecognitionException,
+    TranslationFailedException,
+    SpeechSynthesisException,
+    AudioProcessingException,
+    ProviderNotAvailableException
+)
+
+
+class TestPerformanceAndErrors:
+    """Integration tests for performance and error scenarios."""
+
+    @pytest.fixture
+    def mock_config(self, tmp_path):
+        """Create mock configuration for testing."""
+        config = Mock(spec=AppConfig)
+        
+        # Processing configuration
+        config.get_processing_config.return_value = {
+            'max_file_size_mb': 100,
+            'supported_audio_formats': ['wav', 'mp3', 'flac'],
+            'temp_dir': str(tmp_path),
+            'cleanup_temp_files': True,
+            'processing_timeout': 300,  # 5 minutes
+            'max_concurrent_requests': 10
+        }
+        
+        # Logging configuration
+        config.get_logging_config.return_value = {
+            'level': 'INFO',
+            'enable_file_logging': False,
+            'log_file_path': str(tmp_path / 'test.log'),
+            'format': '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+        }
+        
+        # STT configuration
+        config.get_stt_config.return_value = {
+            'preferred_providers': ['whisper-small', 'whisper-medium', 'parakeet'],
+            'provider_timeout': 60.0,
+            'max_retries': 2
+        }
+        
+        # TTS configuration
+        config.get_tts_config.return_value = {
+            'preferred_providers': ['kokoro', 'dia', 'cosyvoice2', 'dummy'],
+            'provider_timeout': 30.0,
+            'max_retries': 3
+        }
+        
+        # Translation configuration
+        config.get_translation_config.return_value = {
+            'provider_timeout': 45.0,
+            'max_retries': 2,
+            'chunk_size': 512
+        }
+        
+        return config
+
+    @pytest.fixture
+    def mock_container(self, mock_config):
+        """Create mock dependency container."""
+        container = Mock(spec=DependencyContainer)
+        container.resolve.return_value = mock_config
+        
+        # Mock providers with configurable behavior
+        self._setup_mock_providers(container)
+        
+        return container
+
+    def _setup_mock_providers(self, container):
+        """Setup mock providers with configurable behavior."""
+        # Mock STT provider
+        mock_stt_provider = Mock()
+        mock_stt_provider.transcribe.return_value = TextContent(
+            text="Performance test transcription",
+            language="en"
+        )
+        container.get_stt_provider.return_value = mock_stt_provider
+        
+        # Mock translation provider
+        mock_translation_provider = Mock()
+        mock_translation_provider.translate.return_value = TextContent(
+            text="Transcripción de prueba de rendimiento",
+            language="es"
+        )
+        container.get_translation_provider.return_value = mock_translation_provider
+        
+        # Mock TTS provider
+        mock_tts_provider = Mock()
+        mock_tts_provider.synthesize.return_value = AudioContent(
+            data=b"performance_test_audio_data",
+            format="wav",
+            sample_rate=22050,
+            duration=3.0
+        )
+        container.get_tts_provider.return_value = mock_tts_provider
+
+    @pytest.fixture
+    def audio_service(self, mock_container, mock_config):
+        """Create audio processing service."""
+        return AudioProcessingApplicationService(mock_container, mock_config)
+
+    @pytest.fixture
+    def sample_request(self):
+        """Create sample processing request."""
+        audio_upload = AudioUploadDto(
+            filename="performance_test.wav",
+            content=b"performance_test_audio_data",
+            content_type="audio/wav",
+            size=len(b"performance_test_audio_data")
+        )
+        
+        return ProcessingRequestDto(
+            audio=audio_upload,
+            asr_model="whisper-small",
+            target_language="es",
+            voice="kokoro",
+            speed=1.0,
+            requires_translation=True
+        )
+
+    def test_processing_time_performance(self, audio_service, sample_request):
+        """Test processing time performance benchmarks."""
+        # Warm up
+        audio_service.process_audio_pipeline(sample_request)
+        
+        # Measure processing time
+        start_time = time.time()
+        result = audio_service.process_audio_pipeline(sample_request)
+        end_time = time.time()
+        
+        processing_time = end_time - start_time
+        
+        assert result.success is True
+        assert result.processing_time > 0
+        assert result.processing_time <= processing_time + 0.1  # Allow small margin
+        
+        # Performance benchmark: should complete within reasonable time
+        assert processing_time < 5.0  # Should complete within 5 seconds for mock providers
+
+    def test_memory_usage_performance(self, audio_service, sample_request):
+        """Test memory usage during processing."""
+        process = psutil.Process(os.getpid())
+        
+        # Measure initial memory
+        initial_memory = process.memory_info().rss
+        
+        # Process multiple requests
+        for _ in range(10):
+            result = audio_service.process_audio_pipeline(sample_request)
+            assert result.success is True
+        
+        # Measure final memory
+        final_memory = process.memory_info().rss
+        memory_increase = final_memory - initial_memory
+        
+        # Memory increase should be reasonable (less than 100MB for test data)
+        assert memory_increase < 100 * 1024 * 1024
+
+    def test_concurrent_processing_performance(self, audio_service, sample_request):
+        """Test performance under concurrent load."""
+        num_threads = 5
+        results_queue = queue.Queue()
+        
+        def process_request():
+            try:
+                start_time = time.time()
+                result = audio_service.process_audio_pipeline(sample_request)
+                end_time = time.time()
+                results_queue.put((result, end_time - start_time))
+            except Exception as e:
+                results_queue.put(e)
+        
+        # Start concurrent processing
+        threads = []
+        start_time = time.time()
+        
+        for _ in range(num_threads):
+            thread = threading.Thread(target=process_request)
+            threads.append(thread)
+            thread.start()
+        
+        # Wait for completion
+        for thread in threads:
+            thread.join()
+        
+        total_time = time.time() - start_time
+        
+        # Collect results
+        results = []
+        processing_times = []
+        
+        while not results_queue.empty():
+            item = results_queue.get()
+            if isinstance(item, Exception):
+                pytest.fail(f"Concurrent processing failed: {item}")
+            result, proc_time = item
+            results.append(result)
+            processing_times.append(proc_time)
+        
+        # Verify all succeeded
+        assert len(results) == num_threads
+        for result in results:
+            assert result.success is True
+        
+        # Performance checks
+        avg_processing_time = sum(processing_times) / len(processing_times)
+        assert avg_processing_time < 10.0  # Average should be reasonable
+        assert total_time < 15.0  # Total concurrent time should be reasonable
+
+    def test_large_file_performance(self, audio_service):
+        """Test performance with large audio files."""
+        # Create large audio file (10MB)
+        large_content = b"x" * (10 * 1024 * 1024)
+        
+        audio_upload = AudioUploadDto(
+            filename="large_performance_test.wav",
+            content=large_content,
+            content_type="audio/wav",
+            size=len(large_content)
+        )
+        
+        request = ProcessingRequestDto(
+            audio=audio_upload,
+            asr_model="whisper-small",
+            target_language="es",
+            voice="kokoro",
+            speed=1.0,
+            requires_translation=True
+        )
+        
+        start_time = time.time()
+        result = audio_service.process_audio_pipeline(request)
+        end_time = time.time()
+        
+        processing_time = end_time - start_time
+        
+        assert result.success is True
+        # Large files should still complete within reasonable time
+        assert processing_time < 30.0
+
+    def test_stt_provider_failure_recovery(self, audio_service, sample_request, mock_container):
+        """Test recovery from STT provider failures."""
+        mock_stt_provider = mock_container.get_stt_provider.return_value
+        
+        # Mock first call to fail, second to succeed
+        mock_stt_provider.transcribe.side_effect = [
+            SpeechRecognitionException("STT provider temporarily unavailable"),
+            TextContent(text="Recovered transcription", language="en")
+        ]
+        
+        result = audio_service.process_audio_pipeline(sample_request)
+        
+        assert result.success is True
+        assert "Recovered transcription" in result.original_text
+
+    def test_translation_provider_failure_recovery(self, audio_service, sample_request, mock_container):
+        """Test recovery from translation provider failures."""
+        mock_translation_provider = mock_container.get_translation_provider.return_value
+        
+        # Mock first call to fail, second to succeed
+        mock_translation_provider.translate.side_effect = [
+            TranslationFailedException("Translation service temporarily unavailable"),
+            TextContent(text="Traducción recuperada", language="es")
+        ]
+        
+        result = audio_service.process_audio_pipeline(sample_request)
+        
+        assert result.success is True
+        assert "Traducción recuperada" in result.translated_text
+
+    def test_tts_provider_failure_recovery(self, audio_service, sample_request, mock_container):
+        """Test recovery from TTS provider failures."""
+        mock_tts_provider = mock_container.get_tts_provider.return_value
+        
+        # Mock first call to fail, second to succeed
+        mock_tts_provider.synthesize.side_effect = [
+            SpeechSynthesisException("TTS provider temporarily unavailable"),
+            AudioContent(
+                data=b"recovered_audio_data",
+                format="wav",
+                sample_rate=22050,
+                duration=2.5
+            )
+        ]
+        
+        result = audio_service.process_audio_pipeline(sample_request)
+        
+        assert result.success is True
+        assert result.audio_path is not None
+
+    def test_multiple_provider_failures(self, audio_service, sample_request, mock_container):
+        """Test handling of multiple provider failures."""
+        # Mock all providers to fail initially
+        mock_stt_provider = mock_container.get_stt_provider.return_value
+        mock_translation_provider = mock_container.get_translation_provider.return_value
+        mock_tts_provider = mock_container.get_tts_provider.return_value
+        
+        mock_stt_provider.transcribe.side_effect = SpeechRecognitionException("STT failed")
+        mock_translation_provider.translate.side_effect = TranslationFailedException("Translation failed")
+        mock_tts_provider.synthesize.side_effect = SpeechSynthesisException("TTS failed")
+        
+        result = audio_service.process_audio_pipeline(sample_request)
+        
+        assert result.success is False
+        assert result.error_message is not None
+        assert result.error_code is not None
+
+    def test_timeout_handling(self, audio_service, sample_request, mock_container):
+        """Test handling of provider timeouts."""
+        mock_stt_provider = mock_container.get_stt_provider.return_value
+        
+        def slow_transcribe(*args, **kwargs):
+            time.sleep(2.0)  # Simulate slow processing
+            return TextContent(text="Slow transcription", language="en")
+        
+        mock_stt_provider.transcribe.side_effect = slow_transcribe
+        
+        start_time = time.time()
+        result = audio_service.process_audio_pipeline(sample_request)
+        end_time = time.time()
+        
+        processing_time = end_time - start_time
+        
+        # Should complete despite slow provider
+        assert result.success is True
+        assert processing_time >= 2.0  # Should include the delay
+
+    def test_invalid_input_handling(self, audio_service):
+        """Test handling of invalid input data."""
+        # Test with invalid audio format
+        invalid_audio = AudioUploadDto(
+            filename="invalid.xyz",
+            content=b"invalid_audio_data",
+            content_type="audio/xyz",
+            size=len(b"invalid_audio_data")
+        )
+        
+        request = ProcessingRequestDto(
+            audio=invalid_audio,
+            asr_model="whisper-small",
+            target_language="es",
+            voice="kokoro",
+            speed=1.0,
+            requires_translation=True
+        )
+        
+        result = audio_service.process_audio_pipeline(request)
+        
+        assert result.success is False
+        assert result.error_code is not None
+        assert "format" in result.error_message.lower() or "unsupported" in result.error_message.lower()
+
+    def test_oversized_file_handling(self, audio_service, mock_config):
+        """Test handling of oversized files."""
+        # Mock config to have small file size limit
+        mock_config.get_processing_config.return_value['max_file_size_mb'] = 1
+        
+        # Create file larger than limit
+        large_content = b"x" * (2 * 1024 * 1024)  # 2MB
+        
+        oversized_audio = AudioUploadDto(
+            filename="oversized.wav",
+            content=large_content,
+            content_type="audio/wav",
+            size=len(large_content)
+        )
+        
+        request = ProcessingRequestDto(
+            audio=oversized_audio,
+            asr_model="whisper-small",
+            target_language="es",
+            voice="kokoro",
+            speed=1.0,
+            requires_translation=True
+        )
+        
+        result = audio_service.process_audio_pipeline(request)
+        
+        assert result.success is False
+        assert result.error_code is not None
+        assert "size" in result.error_message.lower() or "large" in result.error_message.lower()
+
+    def test_corrupted_audio_handling(self, audio_service):
+        """Test handling of corrupted audio data."""
+        corrupted_audio = AudioUploadDto(
+            filename="corrupted.wav",
+            content=b"corrupted_data_not_audio",
+            content_type="audio/wav",
+            size=len(b"corrupted_data_not_audio")
+        )
+        
+        request = ProcessingRequestDto(
+            audio=corrupted_audio,
+            asr_model="whisper-small",
+            target_language="es",
+            voice="kokoro",
+            speed=1.0,
+            requires_translation=True
+        )
+        
+        result = audio_service.process_audio_pipeline(request)
+        
+        # Should handle gracefully (success depends on implementation)
+        assert result.error_message is None or "audio" in result.error_message.lower()
+
+    def test_network_error_simulation(self, audio_service, sample_request, mock_container):
+        """Test handling of network-related errors."""
+        mock_translation_provider = mock_container.get_translation_provider.return_value
+        
+        # Simulate network errors
+        mock_translation_provider.translate.side_effect = [
+            ConnectionError("Network connection failed"),
+            TimeoutError("Request timed out"),
+            TextContent(text="Network recovered translation", language="es")
+        ]
+        
+        result = audio_service.process_audio_pipeline(sample_request)
+        
+        # Should recover from network errors
+        assert result.success is True
+        assert "Network recovered translation" in result.translated_text
+
+    def test_resource_exhaustion_handling(self, audio_service, sample_request):
+        """Test handling of resource exhaustion scenarios."""
+        # Simulate memory pressure by processing many requests
+        results = []
+        
+        for i in range(20):  # Process many requests
+            result = audio_service.process_audio_pipeline(sample_request)
+            results.append(result)
+            
+            # All should succeed despite resource pressure
+            assert result.success is True
+        
+        # Verify all completed successfully
+        assert len(results) == 20
+        for result in results:
+            assert result.success is True
+
+    def test_error_correlation_tracking(self, audio_service, sample_request, mock_container):
+        """Test error correlation tracking across pipeline stages."""
+        mock_stt_provider = mock_container.get_stt_provider.return_value
+        mock_stt_provider.transcribe.side_effect = SpeechRecognitionException("STT correlation test error")
+        
+        result = audio_service.process_audio_pipeline(sample_request)
+        
+        assert result.success is False
+        assert result.metadata is not None
+        assert 'correlation_id' in result.metadata
+        
+        # Verify correlation ID is consistent
+        correlation_id = result.metadata['correlation_id']
+        assert isinstance(correlation_id, str)
+        assert len(correlation_id) > 0
+
+    def test_graceful_degradation(self, audio_service, sample_request, mock_container):
+        """Test graceful degradation when some features fail."""
+        # Mock translation to fail but allow STT and TTS to succeed
+        mock_translation_provider = mock_container.get_translation_provider.return_value
+        mock_translation_provider.translate.side_effect = TranslationFailedException("Translation unavailable")
+        
+        # Modify request to not require translation
+        sample_request.requires_translation = False
+        sample_request.target_language = "en"  # Same as source
+        
+        result = audio_service.process_audio_pipeline(sample_request)
+        
+        # Should succeed without translation
+        assert result.success is True
+        assert result.translated_text is None  # No translation performed
+
+    def test_circuit_breaker_behavior(self, audio_service, sample_request, mock_container):
+        """Test circuit breaker behavior under repeated failures."""
+        mock_tts_provider = mock_container.get_tts_provider.return_value
+        
+        # Mock repeated failures to trigger circuit breaker
+        mock_tts_provider.synthesize.side_effect = SpeechSynthesisException("Repeated TTS failure")
+        
+        results = []
+        for _ in range(5):  # Multiple attempts
+            result = audio_service.process_audio_pipeline(sample_request)
+            results.append(result)
+        
+        # All should fail, but circuit breaker should prevent excessive retries
+        for result in results:
+            assert result.success is False
+            assert result.error_code is not None
+
+    def test_performance_metrics_collection(self, audio_service, sample_request):
+        """Test collection of performance metrics."""
+        result = audio_service.process_audio_pipeline(sample_request)
+        
+        assert result.success is True
+        assert result.processing_time > 0
+        assert result.metadata is not None
+        
+        # Verify performance-related metadata
+        metadata = result.metadata
+        assert 'correlation_id' in metadata
+        assert 'asr_model' in metadata
+        assert 'target_language' in metadata
+        assert 'voice' in metadata
+
+    def test_stress_testing(self, audio_service, sample_request):
+        """Test system behavior under stress conditions."""
+        num_requests = 50
+        results = []
+        
+        start_time = time.time()
+        
+        for i in range(num_requests):
+            result = audio_service.process_audio_pipeline(sample_request)
+            results.append(result)
+        
+        end_time = time.time()
+        total_time = end_time - start_time
+        
+        # Verify all requests completed
+        assert len(results) == num_requests
+        
+        # Calculate success rate
+        successful_results = [r for r in results if r.success]
+        success_rate = len(successful_results) / len(results)
+        
+        # Should maintain high success rate under stress
+        assert success_rate >= 0.95  # At least 95% success rate
+        
+        # Performance should remain reasonable
+        avg_time_per_request = total_time / num_requests
+        assert avg_time_per_request < 1.0  # Average less than 1 second per request

tests/integration/test_provider_integration.py

@@ -0,0 +1,462 @@
+"""Integration tests for provider integration and switching."""
+
+import pytest
+from unittest.mock import Mock, patch, MagicMock
+from typing import Dict, Any, List
+
+from src.infrastructure.config.dependency_container import DependencyContainer
+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
+from src.domain.models.audio_content import AudioContent
+from src.domain.models.text_content import TextContent
+from src.domain.models.speech_synthesis_request import SpeechSynthesisRequest
+from src.domain.models.translation_request import TranslationRequest
+from src.domain.models.voice_settings import VoiceSettings
+from src.domain.exceptions import (
+    SpeechRecognitionException,
+    TranslationFailedException,
+    SpeechSynthesisException,
+    ProviderNotAvailableException
+)
+
+
+class TestProviderIntegration:
+    """Integration tests for provider integration and switching."""
+
+    @pytest.fixture
+    def mock_config(self):
+        """Create mock configuration for testing."""
+        config = Mock(spec=AppConfig)
+        
+        # TTS configuration
+        config.tts.preferred_providers = ['kokoro', 'dia', 'cosyvoice2', 'dummy']
+        config.tts.fallback_enabled = True
+        config.tts.provider_timeout = 30.0
+        
+        # STT configuration
+        config.stt.default_model = 'whisper-small'
+        config.stt.fallback_models = ['whisper-medium', 'parakeet']
+        config.stt.provider_timeout = 60.0
+        
+        # Translation configuration
+        config.translation.default_provider = 'nllb'
+        config.translation.fallback_enabled = True
+        config.translation.chunk_size = 512
+        
+        return config
+
+    @pytest.fixture
+    def dependency_container(self, mock_config):
+        """Create dependency container with mock configuration."""
+        container = DependencyContainer(mock_config)
+        return container
+
+    @pytest.fixture
+    def sample_audio_content(self):
+        """Create sample audio content for testing."""
+        return AudioContent(
+            data=b"fake_audio_data",
+            format="wav",
+            sample_rate=16000,
+            duration=2.5
+        )
+
+    @pytest.fixture
+    def sample_text_content(self):
+        """Create sample text content for testing."""
+        return TextContent(
+            text="Hello, this is a test message.",
+            language="en"
+        )
+
+    def test_tts_provider_switching(self, dependency_container, sample_text_content):
+        """Test switching between different TTS providers."""
+        voice_settings = VoiceSettings(
+            voice_id="test_voice",
+            speed=1.0,
+            language="en"
+        )
+        
+        synthesis_request = SpeechSynthesisRequest(
+            text=sample_text_content.text,
+            voice_settings=voice_settings
+        )
+        
+        # Test each TTS provider
+        providers_to_test = ['kokoro', 'dia', 'cosyvoice2', 'dummy']
+        
+        for provider_name in providers_to_test:
+            with patch(f'src.infrastructure.tts.{provider_name}_provider') as mock_provider_module:
+                # Mock the provider class
+                mock_provider_class = Mock()
+                mock_provider_instance = Mock()
+                mock_provider_instance.synthesize.return_value = AudioContent(
+                    data=f"{provider_name}_audio_data".encode(),
+                    format="wav",
+                    sample_rate=22050,
+                    duration=2.0
+                )
+                mock_provider_class.return_value = mock_provider_instance
+                setattr(mock_provider_module, f'{provider_name.title()}Provider', mock_provider_class)
+                
+                # Get provider from container
+                provider = dependency_container.get_tts_provider(provider_name)
+                
+                # Test synthesis
+                result = provider.synthesize(synthesis_request)
+                
+                assert isinstance(result, AudioContent)
+                assert provider_name.encode() in result.data
+                mock_provider_instance.synthesize.assert_called_once()
+
+    def test_tts_provider_fallback(self, dependency_container, sample_text_content):
+        """Test TTS provider fallback mechanism."""
+        voice_settings = VoiceSettings(
+            voice_id="test_voice",
+            speed=1.0,
+            language="en"
+        )
+        
+        synthesis_request = SpeechSynthesisRequest(
+            text=sample_text_content.text,
+            voice_settings=voice_settings
+        )
+        
+        with patch('src.infrastructure.tts.provider_factory.TTSProviderFactory') as mock_factory_class:
+            mock_factory = Mock()
+            mock_factory_class.return_value = mock_factory
+            
+            # Mock first provider to fail, second to succeed
+            mock_provider1 = Mock()
+            mock_provider1.synthesize.side_effect = SpeechSynthesisException("Provider 1 failed")
+            
+            mock_provider2 = Mock()
+            mock_provider2.synthesize.return_value = AudioContent(
+                data=b"fallback_audio_data",
+                format="wav",
+                sample_rate=22050,
+                duration=2.0
+            )
+            
+            mock_factory.get_provider_with_fallback.return_value = mock_provider2
+            
+            # Get provider with fallback
+            provider = dependency_container.get_tts_provider()
+            result = provider.synthesize(synthesis_request)
+            
+            assert isinstance(result, AudioContent)
+            assert b"fallback_audio_data" in result.data
+
+    def test_stt_provider_switching(self, dependency_container, sample_audio_content):
+        """Test switching between different STT providers."""
+        providers_to_test = ['whisper-small', 'whisper-medium', 'parakeet']
+        
+        for provider_name in providers_to_test:
+            with patch('src.infrastructure.stt.provider_factory.STTProviderFactory') as mock_factory_class:
+                mock_factory = Mock()
+                mock_factory_class.return_value = mock_factory
+                
+                mock_provider = Mock()
+                mock_provider.transcribe.return_value = TextContent(
+                    text=f"Transcription from {provider_name}",
+                    language="en"
+                )
+                mock_factory.create_provider.return_value = mock_provider
+                
+                # Get provider from container
+                provider = dependency_container.get_stt_provider(provider_name)
+                
+                # Test transcription
+                result = provider.transcribe(sample_audio_content, provider_name)
+                
+                assert isinstance(result, TextContent)
+                assert provider_name in result.text
+                mock_provider.transcribe.assert_called_once()
+
+    def test_stt_provider_fallback(self, dependency_container, sample_audio_content):
+        """Test STT provider fallback mechanism."""
+        with patch('src.infrastructure.stt.provider_factory.STTProviderFactory') as mock_factory_class:
+            mock_factory = Mock()
+            mock_factory_class.return_value = mock_factory
+            
+            # Mock first provider to fail, fallback to succeed
+            mock_provider1 = Mock()
+            mock_provider1.transcribe.side_effect = SpeechRecognitionException("Provider 1 failed")
+            
+            mock_provider2 = Mock()
+            mock_provider2.transcribe.return_value = TextContent(
+                text="Fallback transcription successful",
+                language="en"
+            )
+            
+            mock_factory.create_provider_with_fallback.return_value = mock_provider2
+            
+            # Get provider with fallback
+            provider = dependency_container.get_stt_provider()
+            result = provider.transcribe(sample_audio_content, "whisper-small")
+            
+            assert isinstance(result, TextContent)
+            assert "Fallback transcription successful" in result.text
+
+    def test_translation_provider_integration(self, dependency_container):
+        """Test translation provider integration."""
+        translation_request = TranslationRequest(
+            text="Hello, how are you?",
+            source_language="en",
+            target_language="es"
+        )
+        
+        with patch('src.infrastructure.translation.provider_factory.TranslationProviderFactory') as mock_factory_class:
+            mock_factory = Mock()
+            mock_factory_class.return_value = mock_factory
+            
+            mock_provider = Mock()
+            mock_provider.translate.return_value = TextContent(
+                text="Hola, ¿cómo estás?",
+                language="es"
+            )
+            mock_factory.get_default_provider.return_value = mock_provider
+            
+            # Get translation provider
+            provider = dependency_container.get_translation_provider()
+            result = provider.translate(translation_request)
+            
+            assert isinstance(result, TextContent)
+            assert result.text == "Hola, ¿cómo estás?"
+            assert result.language == "es"
+
+    def test_provider_availability_checking(self, dependency_container):
+        """Test provider availability checking."""
+        with patch('src.infrastructure.tts.provider_factory.TTSProviderFactory') as mock_factory_class:
+            mock_factory = Mock()
+            mock_factory_class.return_value = mock_factory
+            
+            # Mock availability checking
+            mock_factory.is_provider_available.side_effect = lambda name: name in ['kokoro', 'dummy']
+            mock_factory.get_available_providers.return_value = ['kokoro', 'dummy']
+            
+            # Test availability
+            available_providers = mock_factory.get_available_providers()
+            
+            assert 'kokoro' in available_providers
+            assert 'dummy' in available_providers
+            assert 'dia' not in available_providers  # Not available in mock
+
+    def test_provider_configuration_loading(self, dependency_container, mock_config):
+        """Test provider configuration loading and validation."""
+        # Test TTS configuration
+        tts_provider = dependency_container.get_tts_provider('dummy')
+        assert tts_provider is not None
+        
+        # Test STT configuration
+        stt_provider = dependency_container.get_stt_provider('whisper-small')
+        assert stt_provider is not None
+        
+        # Test translation configuration
+        translation_provider = dependency_container.get_translation_provider()
+        assert translation_provider is not None
+
+    def test_provider_error_handling(self, dependency_container, sample_audio_content):
+        """Test provider error handling and recovery."""
+        with patch('src.infrastructure.stt.provider_factory.STTProviderFactory') as mock_factory_class:
+            mock_factory = Mock()
+            mock_factory_class.return_value = mock_factory
+            
+            # Mock provider that always fails
+            mock_provider = Mock()
+            mock_provider.transcribe.side_effect = SpeechRecognitionException("Provider unavailable")
+            mock_factory.create_provider.return_value = mock_provider
+            
+            # Test error handling
+            provider = dependency_container.get_stt_provider('whisper-small')
+            
+            with pytest.raises(SpeechRecognitionException):
+                provider.transcribe(sample_audio_content, 'whisper-small')
+
+    def test_provider_performance_monitoring(self, dependency_container, sample_text_content):
+        """Test provider performance monitoring."""
+        import time
+        
+        voice_settings = VoiceSettings(
+            voice_id="test_voice",
+            speed=1.0,
+            language="en"
+        )
+        
+        synthesis_request = SpeechSynthesisRequest(
+            text=sample_text_content.text,
+            voice_settings=voice_settings
+        )
+        
+        with patch('src.infrastructure.tts.provider_factory.TTSProviderFactory') as mock_factory_class:
+            mock_factory = Mock()
+            mock_factory_class.return_value = mock_factory
+            
+            mock_provider = Mock()
+            
+            def slow_synthesize(request):
+                time.sleep(0.1)  # Simulate processing time
+                return AudioContent(
+                    data=b"slow_audio_data",
+                    format="wav",
+                    sample_rate=22050,
+                    duration=2.0
+                )
+            
+            mock_provider.synthesize.side_effect = slow_synthesize
+            mock_factory.create_provider.return_value = mock_provider
+            
+            # Measure performance
+            start_time = time.time()
+            provider = dependency_container.get_tts_provider('dummy')
+            result = provider.synthesize(synthesis_request)
+            end_time = time.time()
+            
+            processing_time = end_time - start_time
+            
+            assert isinstance(result, AudioContent)
+            assert processing_time >= 0.1  # Should take at least the sleep time
+
+    def test_provider_resource_cleanup(self, dependency_container):
+        """Test provider resource cleanup."""
+        # Get multiple providers
+        tts_provider = dependency_container.get_tts_provider('dummy')
+        stt_provider = dependency_container.get_stt_provider('whisper-small')
+        translation_provider = dependency_container.get_translation_provider()
+        
+        assert tts_provider is not None
+        assert stt_provider is not None
+        assert translation_provider is not None
+        
+        # Test cleanup
+        dependency_container.cleanup()
+        
+        # Verify cleanup was called (would need to mock the actual providers)
+        # This is more of a smoke test to ensure cleanup doesn't crash
+
+    def test_provider_concurrent_access(self, dependency_container, sample_text_content):
+        """Test concurrent access to providers."""
+        import threading
+        import queue
+        
+        voice_settings = VoiceSettings(
+            voice_id="test_voice",
+            speed=1.0,
+            language="en"
+        )
+        
+        synthesis_request = SpeechSynthesisRequest(
+            text=sample_text_content.text,
+            voice_settings=voice_settings
+        )
+        
+        results_queue = queue.Queue()
+        
+        def synthesize_audio():
+            try:
+                provider = dependency_container.get_tts_provider('dummy')
+                with patch.object(provider, 'synthesize') as mock_synthesize:
+                    mock_synthesize.return_value = AudioContent(
+                        data=b"concurrent_audio_data",
+                        format="wav",
+                        sample_rate=22050,
+                        duration=2.0
+                    )
+                    result = provider.synthesize(synthesis_request)
+                    results_queue.put(result)
+            except Exception as e:
+                results_queue.put(e)
+        
+        # Start multiple threads
+        threads = []
+        for _ in range(3):
+            thread = threading.Thread(target=synthesize_audio)
+            threads.append(thread)
+            thread.start()
+        
+        # Wait for completion
+        for thread in threads:
+            thread.join()
+        
+        # Verify results
+        results = []
+        while not results_queue.empty():
+            result = results_queue.get()
+            if isinstance(result, Exception):
+                pytest.fail(f"Concurrent access failed: {result}")
+            results.append(result)
+        
+        assert len(results) == 3
+        for result in results:
+            assert isinstance(result, AudioContent)
+
+    def test_provider_configuration_updates(self, dependency_container, mock_config):
+        """Test dynamic provider configuration updates."""
+        # Initial configuration
+        initial_providers = mock_config.tts.preferred_providers
+        assert 'kokoro' in initial_providers
+        
+        # Update configuration
+        mock_config.tts.preferred_providers = ['dia', 'dummy']
+        
+        # Verify configuration update affects provider selection
+        # (This would require actual implementation of dynamic config updates)
+        updated_providers = mock_config.tts.preferred_providers
+        assert 'dia' in updated_providers
+        assert 'dummy' in updated_providers
+
+    def test_provider_health_checking(self, dependency_container):
+        """Test provider health checking mechanisms."""
+        with patch('src.infrastructure.tts.provider_factory.TTSProviderFactory') as mock_factory_class:
+            mock_factory = Mock()
+            mock_factory_class.return_value = mock_factory
+            
+            # Mock health check methods
+            mock_factory.check_provider_health.return_value = {
+                'kokoro': {'status': 'healthy', 'response_time': 0.1},
+                'dia': {'status': 'unhealthy', 'error': 'Connection timeout'},
+                'dummy': {'status': 'healthy', 'response_time': 0.05}
+            }
+            
+            health_status = mock_factory.check_provider_health()
+            
+            assert health_status['kokoro']['status'] == 'healthy'
+            assert health_status['dia']['status'] == 'unhealthy'
+            assert health_status['dummy']['status'] == 'healthy'
+
+    def test_provider_load_balancing(self, dependency_container):
+        """Test provider load balancing mechanisms."""
+        with patch('src.infrastructure.tts.provider_factory.TTSProviderFactory') as mock_factory_class:
+            mock_factory = Mock()
+            mock_factory_class.return_value = mock_factory
+            
+            # Mock load balancing
+            provider_calls = {'kokoro': 0, 'dia': 0, 'dummy': 0}
+            
+            def mock_get_provider(name=None):
+                if name is None:
+                    # Round-robin selection
+                    providers = ['kokoro', 'dia', 'dummy']
+                    selected = min(providers, key=lambda p: provider_calls[p])
+                    provider_calls[selected] += 1
+                    name = selected
+                
+                mock_provider = Mock()
+                mock_provider.name = name
+                return mock_provider
+            
+            mock_factory.create_provider.side_effect = mock_get_provider
+            
+            # Get multiple providers to test load balancing
+            providers = []
+            for _ in range(6):
+                provider = mock_factory.create_provider()
+                providers.append(provider)
+            
+            # Verify load distribution
+            provider_names = [p.name for p in providers]
+            assert provider_names.count('kokoro') == 2
+            assert provider_names.count('dia') == 2
+            assert provider_names.count('dummy') == 2