remove tests

tests/integration/__init__.py

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

tests/integration/test_audio_processing_pipeline.py

@@ -1,452 +0,0 @@
-"""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': ['parakeet', 'whisper-small', 'whisper-medium']
-        }
-
-        # TTS configuration
-        config.get_tts_config.return_value = {
-            'preferred_providers': ['chatterbox']
-        }
-
-        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="chatterbox",
-            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="chatterbox",
-            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="chatterbox",
-            speed=1.5,
-            requires_translation=True
-        )
-
-        result = audio_service.process_audio_pipeline(request)
-
-        assert result.success is True
-        assert result.metadata['voice'] == "chatterbox"
-        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="chatterbox",
-            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="chatterbox",
-                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

@@ -1,580 +0,0 @@
-"""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': ['chatterbox']
-        }
-        
-        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="chatterbox",
-            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="chatterbox",
-                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="chatterbox",
-            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="chatterbox",
-            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="chatterbox",
-            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="chatterbox",
-            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="chatterbox",
-                    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="chatterbox",
-            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="chatterbox",
-            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="chatterbox",
-                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="chatterbox",
-            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="chatterbox",
-                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="chatterbox",
-            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="chatterbox",
-            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

@@ -1,550 +0,0 @@
-"""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': ['parakeet', 'whisper-small', 'whisper-medium'],
-            'provider_timeout': 60.0,
-            'max_retries': 2
-        }
-
-        # TTS configuration
-        config.get_tts_config.return_value = {
-            'preferred_providers': ['chatterbox'],
-            '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="chatterbox",
-            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="chatterbox",
-            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="chatterbox",
-            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="chatterbox",
-            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="chatterbox",
-            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

@@ -1,462 +0,0 @@
-"""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 = ['chatterbox']
-        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 = ['chatterbox']
-        
-        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('chatterbox')
-        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('chatterbox')
-            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('chatterbox')
-        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('chatterbox')
-                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 'chatterbox' in initial_providers
-        
-        # Update configuration
-        mock_config.tts.preferred_providers = ['chatterbox']
-        
-        # Verify configuration update affects provider selection
-        # (This would require actual implementation of dynamic config updates)
-        updated_providers = mock_config.tts.preferred_providers
-        assert 'chatterbox' 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

tests/unit/application/__init__.py

@@ -1 +0,0 @@
-"""Unit tests for application layer"""

tests/unit/application/dtos/__init__.py

@@ -1 +0,0 @@
-"""Unit tests for application DTOs"""

tests/unit/application/dtos/test_audio_upload_dto.py

@@ -1,245 +0,0 @@
-"""Unit tests for AudioUploadDto"""
-
-import pytest
-import os
-
-from src.application.dtos.audio_upload_dto import AudioUploadDto
-
-
-class TestAudioUploadDto:
-    """Test cases for AudioUploadDto"""
-
-    def test_valid_audio_upload_dto(self):
-        """Test creating a valid AudioUploadDto"""
-        filename = "test_audio.wav"
-        content = b"fake_audio_content_" + b"x" * 1000  # 1KB+ of fake audio
-        content_type = "audio/wav"
-        
-        dto = AudioUploadDto(
-            filename=filename,
-            content=content,
-            content_type=content_type
-        )
-        
-        assert dto.filename == filename
-        assert dto.content == content
-        assert dto.content_type == content_type
-        assert dto.size == len(content)
-
-    def test_audio_upload_dto_with_explicit_size(self):
-        """Test creating AudioUploadDto with explicit size"""
-        filename = "test_audio.mp3"
-        content = b"fake_audio_content_" + b"x" * 2000
-        content_type = "audio/mpeg"
-        size = 2500
-        
-        dto = AudioUploadDto(
-            filename=filename,
-            content=content,
-            content_type=content_type,
-            size=size
-        )
-        
-        assert dto.size == size  # Should use explicit size, not calculated
-
-    def test_empty_filename_validation(self):
-        """Test validation with empty filename"""
-        with pytest.raises(ValueError, match="Filename cannot be empty"):
-            AudioUploadDto(
-                filename="",
-                content=b"fake_audio_content_" + b"x" * 1000,
-                content_type="audio/wav"
-            )
-
-    def test_empty_content_validation(self):
-        """Test validation with empty content"""
-        with pytest.raises(ValueError, match="Audio content cannot be empty"):
-            AudioUploadDto(
-                filename="test.wav",
-                content=b"",
-                content_type="audio/wav"
-            )
-
-    def test_empty_content_type_validation(self):
-        """Test validation with empty content type"""
-        with pytest.raises(ValueError, match="Content type cannot be empty"):
-            AudioUploadDto(
-                filename="test.wav",
-                content=b"fake_audio_content_" + b"x" * 1000,
-                content_type=""
-            )
-
-    def test_unsupported_file_extension_validation(self):
-        """Test validation with unsupported file extension"""
-        with pytest.raises(ValueError, match="Unsupported file extension"):
-            AudioUploadDto(
-                filename="test.xyz",
-                content=b"fake_audio_content_" + b"x" * 1000,
-                content_type="audio/wav"
-            )
-
-    def test_supported_file_extensions(self):
-        """Test all supported file extensions"""
-        supported_extensions = ['.wav', '.mp3', '.m4a', '.flac', '.ogg']
-        content = b"fake_audio_content_" + b"x" * 1000
-        
-        for ext in supported_extensions:
-            filename = f"test{ext}"
-            content_type = f"audio/{ext[1:]}" if ext != '.m4a' else "audio/mp4"
-            
-            # Should not raise exception
-            dto = AudioUploadDto(
-                filename=filename,
-                content=content,
-                content_type=content_type
-            )
-            assert dto.file_extension == ext
-
-    def test_case_insensitive_extension_validation(self):
-        """Test case insensitive extension validation"""
-        content = b"fake_audio_content_" + b"x" * 1000
-        
-        # Should work with uppercase extension
-        dto = AudioUploadDto(
-            filename="test.WAV",
-            content=content,
-            content_type="audio/wav"
-        )
-        assert dto.file_extension == ".wav"  # Should be normalized to lowercase
-
-    def test_file_too_large_validation(self):
-        """Test validation with file too large"""
-        max_size = 100 * 1024 * 1024  # 100MB
-        large_content = b"x" * (max_size + 1)
-        
-        with pytest.raises(ValueError, match="File too large"):
-            AudioUploadDto(
-                filename="test.wav",
-                content=large_content,
-                content_type="audio/wav"
-            )
-
-    def test_file_too_small_validation(self):
-        """Test validation with file too small"""
-        small_content = b"x" * 500  # Less than 1KB
-        
-        with pytest.raises(ValueError, match="File too small"):
-            AudioUploadDto(
-                filename="test.wav",
-                content=small_content,
-                content_type="audio/wav"
-            )
-
-    def test_invalid_content_type_validation(self):
-        """Test validation with invalid content type"""
-        content = b"fake_audio_content_" + b"x" * 1000
-        
-        with pytest.raises(ValueError, match="Invalid content type"):
-            AudioUploadDto(
-                filename="test.wav",
-                content=content,
-                content_type="text/plain"  # Not audio/*
-            )
-
-    def test_file_extension_property(self):
-        """Test file_extension property"""
-        dto = AudioUploadDto(
-            filename="test_audio.MP3",
-            content=b"fake_audio_content_" + b"x" * 1000,
-            content_type="audio/mpeg"
-        )
-        
-        assert dto.file_extension == ".mp3"
-
-    def test_base_filename_property(self):
-        """Test base_filename property"""
-        dto = AudioUploadDto(
-            filename="test_audio.wav",
-            content=b"fake_audio_content_" + b"x" * 1000,
-            content_type="audio/wav"
-        )
-        
-        assert dto.base_filename == "test_audio"
-
-    def test_to_dict_method(self):
-        """Test to_dict method"""
-        filename = "test_audio.wav"
-        content = b"fake_audio_content_" + b"x" * 1000
-        content_type = "audio/wav"
-        
-        dto = AudioUploadDto(
-            filename=filename,
-            content=content,
-            content_type=content_type
-        )
-        
-        result = dto.to_dict()
-        
-        assert result['filename'] == filename
-        assert result['content_type'] == content_type
-        assert result['size'] == len(content)
-        assert result['file_extension'] == ".wav"
-        
-        # Should not include content in dict representation
-        assert 'content' not in result
-
-    def test_size_calculation_on_init(self):
-        """Test that size is calculated automatically if not provided"""
-        content = b"fake_audio_content_" + b"x" * 1500
-        
-        dto = AudioUploadDto(
-            filename="test.wav",
-            content=content,
-            content_type="audio/wav"
-        )
-        
-        assert dto.size == len(content)
-
-    def test_validation_called_on_init(self):
-        """Test that validation is called during initialization"""
-        # This should trigger validation and raise an error
-        with pytest.raises(ValueError):
-            AudioUploadDto(
-                filename="",  # Invalid empty filename
-                content=b"fake_audio_content_" + b"x" * 1000,
-                content_type="audio/wav"
-            )
-
-    def test_edge_case_minimum_valid_size(self):
-        """Test edge case with minimum valid file size"""
-        min_content = b"x" * 1024  # Exactly 1KB
-        
-        dto = AudioUploadDto(
-            filename="test.wav",
-            content=min_content,
-            content_type="audio/wav"
-        )
-        
-        assert dto.size == 1024
-
-    def test_edge_case_maximum_valid_size(self):
-        """Test edge case with maximum valid file size"""
-        max_size = 100 * 1024 * 1024  # Exactly 100MB
-        max_content = b"x" * max_size
-        
-        dto = AudioUploadDto(
-            filename="test.wav",
-            content=max_content,
-            content_type="audio/wav"
-        )
-        
-        assert dto.size == max_size
-
-    def test_content_type_mismatch_handling(self):
-        """Test handling of content type mismatch with filename"""
-        content = b"fake_audio_content_" + b"x" * 1000
-        
-        # This should still work as long as content_type starts with 'audio/'
-        dto = AudioUploadDto(
-            filename="test.wav",
-            content=content,
-            content_type="audio/mpeg"  # Different from .wav extension
-        )
-        
-        assert dto.content_type == "audio/mpeg"
-        assert dto.file_extension == ".wav"

tests/unit/application/dtos/test_dto_validation.py

@@ -1,319 +0,0 @@
-"""Unit tests for DTO validation utilities"""
-
-import pytest
-from unittest.mock import Mock
-
-from src.application.dtos.dto_validation import (
-    ValidationError,
-    validate_dto,
-    validation_required,
-    validate_field,
-    validate_required,
-    validate_type,
-    validate_range,
-    validate_choices
-)
-
-
-class TestValidationError:
-    """Test cases for ValidationError"""
-
-    def test_validation_error_basic(self):
-        """Test basic ValidationError creation"""
-        error = ValidationError("Test error message")
-        
-        assert str(error) == "Validation error: Test error message"
-        assert error.message == "Test error message"
-        assert error.field is None
-        assert error.value is None
-
-    def test_validation_error_with_field(self):
-        """Test ValidationError with field information"""
-        error = ValidationError("Invalid value", field="test_field", value="invalid_value")
-        
-        assert str(error) == "Validation error for field 'test_field': Invalid value"
-        assert error.message == "Invalid value"
-        assert error.field == "test_field"
-        assert error.value == "invalid_value"
-
-    def test_validation_error_without_field_but_with_value(self):
-        """Test ValidationError without field but with value"""
-        error = ValidationError("Invalid value", value="test_value")
-        
-        assert str(error) == "Validation error: Invalid value"
-        assert error.message == "Invalid value"
-        assert error.field is None
-        assert error.value == "test_value"
-
-
-class TestValidateDto:
-    """Test cases for validate_dto function"""
-
-    def test_validate_dto_success_with_validate_method(self):
-        """Test successful DTO validation with _validate method"""
-        mock_dto = Mock()
-        mock_dto._validate = Mock()
-        
-        result = validate_dto(mock_dto)
-        
-        assert result is True
-        mock_dto._validate.assert_called_once()
-
-    def test_validate_dto_success_without_validate_method(self):
-        """Test successful DTO validation without _validate method"""
-        mock_dto = Mock()
-        del mock_dto._validate  # Remove the _validate method
-        
-        result = validate_dto(mock_dto)
-        
-        assert result is True
-
-    def test_validate_dto_failure_value_error(self):
-        """Test DTO validation failure with ValueError"""
-        mock_dto = Mock()
-        mock_dto._validate.side_effect = ValueError("Validation failed")
-        
-        with pytest.raises(ValidationError, match="Validation failed"):
-            validate_dto(mock_dto)
-
-    def test_validate_dto_failure_unexpected_error(self):
-        """Test DTO validation failure with unexpected error"""
-        mock_dto = Mock()
-        mock_dto._validate.side_effect = RuntimeError("Unexpected error")
-        
-        with pytest.raises(ValidationError, match="Validation failed: Unexpected error"):
-            validate_dto(mock_dto)
-
-
-class TestValidationRequired:
-    """Test cases for validation_required decorator"""
-
-    def test_validation_required_success(self):
-        """Test validation_required decorator with successful validation"""
-        mock_instance = Mock()
-        mock_instance._validate = Mock()
-        
-        @validation_required
-        def test_method(self):
-            return "success"
-        
-        result = test_method(mock_instance)
-        
-        assert result == "success"
-        mock_instance._validate.assert_called_once()
-
-    def test_validation_required_validation_error(self):
-        """Test validation_required decorator with validation error"""
-        mock_instance = Mock()
-        mock_instance._validate.side_effect = ValueError("Validation failed")
-        
-        @validation_required
-        def test_method(self):
-            return "success"
-        
-        with pytest.raises(ValidationError, match="Validation failed"):
-            test_method(mock_instance)
-
-    def test_validation_required_method_error(self):
-        """Test validation_required decorator with method execution error"""
-        mock_instance = Mock()
-        mock_instance._validate = Mock()
-        
-        @validation_required
-        def test_method(self):
-            raise RuntimeError("Method error")
-        
-        with pytest.raises(ValidationError, match="Error in test_method: Method error"):
-            test_method(mock_instance)
-
-    def test_validation_required_preserves_function_metadata(self):
-        """Test that validation_required preserves function metadata"""
-        @validation_required
-        def test_method(self):
-            """Test method docstring"""
-            return "success"
-        
-        assert test_method.__name__ == "test_method"
-        assert test_method.__doc__ == "Test method docstring"
-
-
-class TestValidateField:
-    """Test cases for validate_field function"""
-
-    def test_validate_field_success(self):
-        """Test successful field validation"""
-        def is_positive(value):
-            return value > 0
-        
-        result = validate_field(5, "test_field", is_positive)
-        
-        assert result == 5
-
-    def test_validate_field_failure_with_custom_message(self):
-        """Test field validation failure with custom error message"""
-        def is_positive(value):
-            return value > 0
-        
-        with pytest.raises(ValidationError, match="Custom error message"):
-            validate_field(-1, "test_field", is_positive, "Custom error message")
-
-    def test_validate_field_failure_with_default_message(self):
-        """Test field validation failure with default error message"""
-        def is_positive(value):
-            return value > 0
-        
-        with pytest.raises(ValidationError, match="Invalid value for field 'test_field'"):
-            validate_field(-1, "test_field", is_positive)
-
-    def test_validate_field_validator_exception(self):
-        """Test field validation with validator raising exception"""
-        def failing_validator(value):
-            raise RuntimeError("Validator error")
-        
-        with pytest.raises(ValidationError, match="Validation error for field 'test_field': Validator error"):
-            validate_field(5, "test_field", failing_validator)
-
-
-class TestValidateRequired:
-    """Test cases for validate_required function"""
-
-    def test_validate_required_success_with_value(self):
-        """Test successful required validation with valid value"""
-        result = validate_required("test_value", "test_field")
-        assert result == "test_value"
-
-    def test_validate_required_success_with_zero(self):
-        """Test successful required validation with zero (falsy but valid)"""
-        result = validate_required(0, "test_field")
-        assert result == 0
-
-    def test_validate_required_success_with_false(self):
-        """Test successful required validation with False (falsy but valid)"""
-        result = validate_required(False, "test_field")
-        assert result is False
-
-    def test_validate_required_failure_with_none(self):
-        """Test required validation failure with None"""
-        with pytest.raises(ValidationError, match="Field 'test_field' is required"):
-            validate_required(None, "test_field")
-
-    def test_validate_required_failure_with_empty_string(self):
-        """Test required validation failure with empty string"""
-        with pytest.raises(ValidationError, match="Field 'test_field' cannot be empty"):
-            validate_required("", "test_field")
-
-    def test_validate_required_failure_with_empty_list(self):
-        """Test required validation failure with empty list"""
-        with pytest.raises(ValidationError, match="Field 'test_field' cannot be empty"):
-            validate_required([], "test_field")
-
-    def test_validate_required_failure_with_empty_dict(self):
-        """Test required validation failure with empty dict"""
-        with pytest.raises(ValidationError, match="Field 'test_field' cannot be empty"):
-            validate_required({}, "test_field")
-
-
-class TestValidateType:
-    """Test cases for validate_type function"""
-
-    def test_validate_type_success_single_type(self):
-        """Test successful type validation with single type"""
-        result = validate_type("test", "test_field", str)
-        assert result == "test"
-
-    def test_validate_type_success_multiple_types(self):
-        """Test successful type validation with multiple types"""
-        result1 = validate_type("test", "test_field", (str, int))
-        assert result1 == "test"
-        
-        result2 = validate_type(123, "test_field", (str, int))
-        assert result2 == 123
-
-    def test_validate_type_failure_single_type(self):
-        """Test type validation failure with single type"""
-        with pytest.raises(ValidationError, match="Field 'test_field' must be of type str, got int"):
-            validate_type(123, "test_field", str)
-
-    def test_validate_type_failure_multiple_types(self):
-        """Test type validation failure with multiple types"""
-        with pytest.raises(ValidationError, match="Field 'test_field' must be of type str or int, got float"):
-            validate_type(1.5, "test_field", (str, int))
-
-
-class TestValidateRange:
-    """Test cases for validate_range function"""
-
-    def test_validate_range_success_within_range(self):
-        """Test successful range validation within range"""
-        result = validate_range(5, "test_field", min_value=1, max_value=10)
-        assert result == 5
-
-    def test_validate_range_success_at_boundaries(self):
-        """Test successful range validation at boundaries"""
-        result1 = validate_range(1, "test_field", min_value=1, max_value=10)
-        assert result1 == 1
-        
-        result2 = validate_range(10, "test_field", min_value=1, max_value=10)
-        assert result2 == 10
-
-    def test_validate_range_success_only_min(self):
-        """Test successful range validation with only minimum"""
-        result = validate_range(5, "test_field", min_value=1)
-        assert result == 5
-
-    def test_validate_range_success_only_max(self):
-        """Test successful range validation with only maximum"""
-        result = validate_range(5, "test_field", max_value=10)
-        assert result == 5
-
-    def test_validate_range_success_no_limits(self):
-        """Test successful range validation with no limits"""
-        result = validate_range(5, "test_field")
-        assert result == 5
-
-    def test_validate_range_failure_below_minimum(self):
-        """Test range validation failure below minimum"""
-        with pytest.raises(ValidationError, match="Field 'test_field' must be >= 1, got 0"):
-            validate_range(0, "test_field", min_value=1, max_value=10)
-
-    def test_validate_range_failure_above_maximum(self):
-        """Test range validation failure above maximum"""
-        with pytest.raises(ValidationError, match="Field 'test_field' must be <= 10, got 11"):
-            validate_range(11, "test_field", min_value=1, max_value=10)
-
-    def test_validate_range_with_float_values(self):
-        """Test range validation with float values"""
-        result = validate_range(1.5, "test_field", min_value=1.0, max_value=2.0)
-        assert result == 1.5
-
-
-class TestValidateChoices:
-    """Test cases for validate_choices function"""
-
-    def test_validate_choices_success(self):
-        """Test successful choices validation"""
-        choices = ["option1", "option2", "option3"]
-        result = validate_choices("option2", "test_field", choices)
-        assert result == "option2"
-
-    def test_validate_choices_failure(self):
-        """Test choices validation failure"""
-        choices = ["option1", "option2", "option3"]
-        
-        with pytest.raises(ValidationError, match="Field 'test_field' must be one of \\['option1', 'option2', 'option3'\\], got 'invalid'"):
-            validate_choices("invalid", "test_field", choices)
-
-    def test_validate_choices_with_different_types(self):
-        """Test choices validation with different value types"""
-        choices = [1, 2, 3, "four"]
-        
-        result1 = validate_choices(2, "test_field", choices)
-        assert result1 == 2
-        
-        result2 = validate_choices("four", "test_field", choices)
-        assert result2 == "four"
-
-    def test_validate_choices_empty_choices(self):
-        """Test choices validation with empty choices list"""
-        with pytest.raises(ValidationError, match="Field 'test_field' must be one of \\[\\], got 'value'"):
-            validate_choices("value", "test_field", [])

tests/unit/application/dtos/test_processing_request_dto.py

@@ -1,383 +0,0 @@
-"""Unit tests for ProcessingRequestDto"""
-
-import pytest
-
-from src.application.dtos.processing_request_dto import ProcessingRequestDto
-from src.application.dtos.audio_upload_dto import AudioUploadDto
-
-
-class TestProcessingRequestDto:
-    """Test cases for ProcessingRequestDto"""
-
-    @pytest.fixture
-    def sample_audio_upload(self):
-        """Create sample audio upload DTO"""
-        return AudioUploadDto(
-            filename="test_audio.wav",
-            content=b"fake_audio_content_" + b"x" * 1000,
-            content_type="audio/wav"
-        )
-
-    def test_valid_processing_request_dto(self, sample_audio_upload):
-        """Test creating a valid ProcessingRequestDto"""
-        dto = ProcessingRequestDto(
-            audio=sample_audio_upload,
-            asr_model="whisper-small",
-            target_language="es",
-            voice="chatterbox",
-            speed=1.0,
-            source_language="en"
-        )
-        
-        assert dto.audio == sample_audio_upload
-        assert dto.asr_model == "whisper-small"
-        assert dto.target_language == "es"
-        assert dto.voice == "kokoro"
-        assert dto.speed == 1.0
-        assert dto.source_language == "en"
-        assert dto.additional_params == {}
-
-    def test_processing_request_dto_with_defaults(self, sample_audio_upload):
-        """Test creating ProcessingRequestDto with default values"""
-        dto = ProcessingRequestDto(
-            audio=sample_audio_upload,
-            asr_model="whisper-medium",
-            target_language="fr",
-            voice="chatterbox"
-        )
-        
-        assert dto.speed == 1.0  # Default speed
-        assert dto.source_language is None  # Default source language
-        assert dto.additional_params == {}  # Default additional params
-
-    def test_processing_request_dto_with_additional_params(self, sample_audio_upload):
-        """Test creating ProcessingRequestDto with additional parameters"""
-        additional_params = {
-            "custom_param": "value",
-            "another_param": 123
-        }
-        
-        dto = ProcessingRequestDto(
-            audio=sample_audio_upload,
-            asr_model="whisper-large",
-            target_language="de",
-            voice="chatterbox",
-            additional_params=additional_params
-        )
-        
-        assert dto.additional_params == additional_params
-
-    def test_invalid_audio_type_validation(self):
-        """Test validation with invalid audio type"""
-        with pytest.raises(ValueError, match="Audio must be an AudioUploadDto instance"):
-            ProcessingRequestDto(
-                audio="invalid_audio",  # Not AudioUploadDto
-                asr_model="whisper-small",
-                target_language="es",
-                voice="chatterbox"
-            )
-
-    def test_empty_asr_model_validation(self, sample_audio_upload):
-        """Test validation with empty ASR model"""
-        with pytest.raises(ValueError, match="ASR model cannot be empty"):
-            ProcessingRequestDto(
-                audio=sample_audio_upload,
-                asr_model="",
-                target_language="es",
-                voice="chatterbox"
-            )
-
-    def test_unsupported_asr_model_validation(self, sample_audio_upload):
-        """Test validation with unsupported ASR model"""
-        with pytest.raises(ValueError, match="Unsupported ASR model"):
-            ProcessingRequestDto(
-                audio=sample_audio_upload,
-                asr_model="invalid-model",
-                target_language="es",
-                voice="chatterbox"
-            )
-
-    def test_supported_asr_models(self, sample_audio_upload):
-        """Test all supported ASR models"""
-        supported_models = ['whisper-small', 'whisper-medium', 'whisper-large', 'parakeet']
-        
-        for model in supported_models:
-            # Should not raise exception
-            dto = ProcessingRequestDto(
-                audio=sample_audio_upload,
-                asr_model=model,
-                target_language="es",
-                voice="chatterbox"
-            )
-            assert dto.asr_model == model
-
-    def test_empty_target_language_validation(self, sample_audio_upload):
-        """Test validation with empty target language"""
-        with pytest.raises(ValueError, match="Target language cannot be empty"):
-            ProcessingRequestDto(
-                audio=sample_audio_upload,
-                asr_model="whisper-small",
-                target_language="",
-                voice="chatterbox"
-            )
-
-    def test_unsupported_target_language_validation(self, sample_audio_upload):
-        """Test validation with unsupported target language"""
-        with pytest.raises(ValueError, match="Unsupported target language"):
-            ProcessingRequestDto(
-                audio=sample_audio_upload,
-                asr_model="whisper-small",
-                target_language="invalid-lang",
-                voice="chatterbox"
-            )
-
-    def test_unsupported_source_language_validation(self, sample_audio_upload):
-        """Test validation with unsupported source language"""
-        with pytest.raises(ValueError, match="Unsupported source language"):
-            ProcessingRequestDto(
-                audio=sample_audio_upload,
-                asr_model="whisper-small",
-                target_language="es",
-                voice="chatterbox",
-                source_language="invalid-lang"
-            )
-
-    def test_supported_languages(self, sample_audio_upload):
-        """Test all supported languages"""
-        supported_languages = [
-            'en', 'es', 'fr', 'de', 'it', 'pt', 'ru', 'ja', 'ko', 'zh',
-            'ar', 'hi', 'tr', 'pl', 'nl', 'sv', 'da', 'no', 'fi'
-        ]
-        
-        for lang in supported_languages:
-            # Should not raise exception
-            dto = ProcessingRequestDto(
-                audio=sample_audio_upload,
-                asr_model="whisper-small",
-                target_language=lang,
-                voice="chatterbox",
-                source_language=lang
-            )
-            assert dto.target_language == lang
-            assert dto.source_language == lang
-
-    def test_empty_voice_validation(self, sample_audio_upload):
-        """Test validation with empty voice"""
-        with pytest.raises(ValueError, match="Voice cannot be empty"):
-            ProcessingRequestDto(
-                audio=sample_audio_upload,
-                asr_model="whisper-small",
-                target_language="es",
-                voice=""
-            )
-
-    def test_unsupported_voice_validation(self, sample_audio_upload):
-        """Test validation with unsupported voice"""
-        with pytest.raises(ValueError, match="Unsupported voice"):
-            ProcessingRequestDto(
-                audio=sample_audio_upload,
-                asr_model="whisper-small",
-                target_language="es",
-                voice="invalid-voice"
-            )
-
-    def test_supported_voices(self, sample_audio_upload):
-        """Test all supported voices"""
-        supported_voices = ['chatterbox']
-        
-        for voice in supported_voices:
-            # Should not raise exception
-            dto = ProcessingRequestDto(
-                audio=sample_audio_upload,
-                asr_model="whisper-small",
-                target_language="es",
-                voice=voice
-            )
-            assert dto.voice == voice
-
-    def test_speed_range_validation_too_low(self, sample_audio_upload):
-        """Test validation with speed too low"""
-        with pytest.raises(ValueError, match="Speed must be between 0.5 and 2.0"):
-            ProcessingRequestDto(
-                audio=sample_audio_upload,
-                asr_model="whisper-small",
-                target_language="es",
-                voice="chatterbox",
-                speed=0.3  # Too low
-            )
-
-    def test_speed_range_validation_too_high(self, sample_audio_upload):
-        """Test validation with speed too high"""
-        with pytest.raises(ValueError, match="Speed must be between 0.5 and 2.0"):
-            ProcessingRequestDto(
-                audio=sample_audio_upload,
-                asr_model="whisper-small",
-                target_language="es",
-                voice="chatterbox",
-                speed=2.5  # Too high
-            )
-
-    def test_valid_speed_range(self, sample_audio_upload):
-        """Test valid speed range"""
-        valid_speeds = [0.5, 1.0, 1.5, 2.0]
-        
-        for speed in valid_speeds:
-            # Should not raise exception
-            dto = ProcessingRequestDto(
-                audio=sample_audio_upload,
-                asr_model="whisper-small",
-                target_language="es",
-                voice="chatterbox",
-                speed=speed
-            )
-            assert dto.speed == speed
-
-    def test_invalid_additional_params_type(self, sample_audio_upload):
-        """Test validation with invalid additional params type"""
-        with pytest.raises(ValueError, match="Additional params must be a dictionary"):
-            ProcessingRequestDto(
-                audio=sample_audio_upload,
-                asr_model="whisper-small",
-                target_language="es",
-                voice="chatterbox",
-                additional_params="invalid"  # Not a dict
-            )
-
-    def test_requires_translation_property_same_language(self, sample_audio_upload):
-        """Test requires_translation property when source and target are same"""
-        dto = ProcessingRequestDto(
-            audio=sample_audio_upload,
-            asr_model="whisper-small",
-            target_language="en",
-            voice="chatterbox",
-            source_language="en"
-        )
-        
-        assert dto.requires_translation is False
-
-    def test_requires_translation_property_different_languages(self, sample_audio_upload):
-        """Test requires_translation property when source and target are different"""
-        dto = ProcessingRequestDto(
-            audio=sample_audio_upload,
-            asr_model="whisper-small",
-            target_language="es",
-            voice="chatterbox",
-            source_language="en"
-        )
-        
-        assert dto.requires_translation is True
-
-    def test_requires_translation_property_no_source(self, sample_audio_upload):
-        """Test requires_translation property when no source language specified"""
-        dto = ProcessingRequestDto(
-            audio=sample_audio_upload,
-            asr_model="whisper-small",
-            target_language="es",
-            voice="chatterbox"
-        )
-        
-        assert dto.requires_translation is True  # Assume translation needed
-
-    def test_to_dict_method(self, sample_audio_upload):
-        """Test to_dict method"""
-        dto = ProcessingRequestDto(
-            audio=sample_audio_upload,
-            asr_model="whisper-small",
-            target_language="es",
-            voice="chatterbox",
-            speed=1.5,
-            source_language="en",
-            additional_params={"custom": "value"}
-        )
-        
-        result = dto.to_dict()
-        
-        assert result['audio'] == sample_audio_upload.to_dict()
-        assert result['asr_model'] == "whisper-small"
-        assert result['target_language'] == "es"
-        assert result['source_language'] == "en"
-        assert result['voice'] == "chatterbox"
-        assert result['speed'] == 1.5
-        assert result['requires_translation'] is True
-        assert result['additional_params'] == {"custom": "value"}
-
-    def test_from_dict_method(self, sample_audio_upload):
-        """Test from_dict class method"""
-        data = {
-            'audio': sample_audio_upload,
-            'asr_model': 'whisper-medium',
-            'target_language': 'fr',
-            'voice': 'dia',
-            'speed': 1.2,
-            'source_language': 'en',
-            'additional_params': {'test': 'value'}
-        }
-        
-        dto = ProcessingRequestDto.from_dict(data)
-        
-        assert dto.audio == sample_audio_upload
-        assert dto.asr_model == 'whisper-medium'
-        assert dto.target_language == 'fr'
-        assert dto.voice == 'dia'
-        assert dto.speed == 1.2
-        assert dto.source_language == 'en'
-        assert dto.additional_params == {'test': 'value'}
-
-    def test_from_dict_method_with_audio_dict(self):
-        """Test from_dict method with audio as dictionary"""
-        audio_data = {
-            'filename': 'test.wav',
-            'content': b'fake_content' + b'x' * 1000,
-            'content_type': 'audio/wav'
-        }
-        
-        data = {
-            'audio': audio_data,
-            'asr_model': 'whisper-small',
-            'target_language': 'es',
-            'voice': 'kokoro'
-        }
-        
-        dto = ProcessingRequestDto.from_dict(data)
-        
-        assert isinstance(dto.audio, AudioUploadDto)
-        assert dto.audio.filename == 'test.wav'
-        assert dto.audio.content_type == 'audio/wav'
-
-    def test_from_dict_method_with_defaults(self, sample_audio_upload):
-        """Test from_dict method with default values"""
-        data = {
-            'audio': sample_audio_upload,
-            'asr_model': 'whisper-small',
-            'target_language': 'es',
-            'voice': 'kokoro'
-        }
-        
-        dto = ProcessingRequestDto.from_dict(data)
-        
-        assert dto.speed == 1.0  # Default
-        assert dto.source_language is None  # Default
-        assert dto.additional_params is None  # Default
-
-    def test_validation_called_on_init(self, sample_audio_upload):
-        """Test that validation is called during initialization"""
-        # This should trigger validation and raise an error
-        with pytest.raises(ValueError):
-            ProcessingRequestDto(
-                audio=sample_audio_upload,
-                asr_model="",  # Invalid empty model
-                target_language="es",
-                voice="chatterbox"
-            )
-
-    def test_additional_params_default_initialization(self, sample_audio_upload):
-        """Test that additional_params is initialized to empty dict if None"""
-        dto = ProcessingRequestDto(
-            audio=sample_audio_upload,
-            asr_model="whisper-small",
-            target_language="es",
-            voice="chatterbox",
-            additional_params=None
-        )
-        
-        assert dto.additional_params == {}

tests/unit/application/dtos/test_processing_result_dto.py

@@ -1,436 +0,0 @@
-"""Unit tests for ProcessingResultDto"""
-
-import pytest
-from datetime import datetime
-
-from src.application.dtos.processing_result_dto import ProcessingResultDto
-
-
-class TestProcessingResultDto:
-    """Test cases for ProcessingResultDto"""
-
-    def test_valid_success_processing_result_dto(self):
-        """Test creating a valid successful ProcessingResultDto"""
-        dto = ProcessingResultDto(
-            success=True,
-            original_text="Hello world",
-            translated_text="Hola mundo",
-            audio_path="/tmp/output.wav",
-            processing_time=5.2,
-            metadata={"correlation_id": "test-123"}
-        )
-        
-        assert dto.success is True
-        assert dto.original_text == "Hello world"
-        assert dto.translated_text == "Hola mundo"
-        assert dto.audio_path == "/tmp/output.wav"
-        assert dto.processing_time == 5.2
-        assert dto.metadata == {"correlation_id": "test-123"}
-        assert dto.error_message is None
-        assert dto.error_code is None
-        assert isinstance(dto.timestamp, datetime)
-
-    def test_valid_error_processing_result_dto(self):
-        """Test creating a valid error ProcessingResultDto"""
-        dto = ProcessingResultDto(
-            success=False,
-            error_message="Processing failed",
-            error_code="STT_ERROR",
-            processing_time=2.1,
-            metadata={"correlation_id": "test-456"}
-        )
-        
-        assert dto.success is False
-        assert dto.error_message == "Processing failed"
-        assert dto.error_code == "STT_ERROR"
-        assert dto.processing_time == 2.1
-        assert dto.metadata == {"correlation_id": "test-456"}
-        assert dto.original_text is None
-        assert dto.translated_text is None
-        assert dto.audio_path is None
-        assert isinstance(dto.timestamp, datetime)
-
-    def test_processing_result_dto_with_defaults(self):
-        """Test creating ProcessingResultDto with default values"""
-        dto = ProcessingResultDto(success=True, original_text="Test")
-        
-        assert dto.success is True
-        assert dto.original_text == "Test"
-        assert dto.translated_text is None
-        assert dto.audio_path is None
-        assert dto.processing_time == 0.0
-        assert dto.error_message is None
-        assert dto.error_code is None
-        assert dto.metadata == {}
-        assert isinstance(dto.timestamp, datetime)
-
-    def test_processing_result_dto_with_explicit_timestamp(self):
-        """Test creating ProcessingResultDto with explicit timestamp"""
-        test_timestamp = datetime(2023, 1, 1, 12, 0, 0)
-        
-        dto = ProcessingResultDto(
-            success=True,
-            original_text="Test",
-            timestamp=test_timestamp
-        )
-        
-        assert dto.timestamp == test_timestamp
-
-    def test_invalid_success_type_validation(self):
-        """Test validation with invalid success type"""
-        with pytest.raises(ValueError, match="Success must be a boolean value"):
-            ProcessingResultDto(
-                success="true",  # String instead of boolean
-                original_text="Test"
-            )
-
-    def test_negative_processing_time_validation(self):
-        """Test validation with negative processing time"""
-        with pytest.raises(ValueError, match="Processing time cannot be negative"):
-            ProcessingResultDto(
-                success=True,
-                original_text="Test",
-                processing_time=-1.0
-            )
-
-    def test_successful_processing_without_output_validation(self):
-        """Test validation for successful processing without any output"""
-        with pytest.raises(ValueError, match="Successful processing must have at least one output"):
-            ProcessingResultDto(
-                success=True,
-                # No original_text, translated_text, or audio_path
-            )
-
-    def test_failed_processing_without_error_message_validation(self):
-        """Test validation for failed processing without error message"""
-        with pytest.raises(ValueError, match="Failed processing must include an error message"):
-            ProcessingResultDto(
-                success=False,
-                # No error_message
-            )
-
-    def test_invalid_error_code_validation(self):
-        """Test validation with invalid error code"""
-        with pytest.raises(ValueError, match="Invalid error code"):
-            ProcessingResultDto(
-                success=False,
-                error_message="Test error",
-                error_code="INVALID_CODE"
-            )
-
-    def test_valid_error_codes(self):
-        """Test all valid error codes"""
-        valid_error_codes = [
-            'STT_ERROR', 'TRANSLATION_ERROR', 'TTS_ERROR',
-            'AUDIO_FORMAT_ERROR', 'VALIDATION_ERROR', 'SYSTEM_ERROR'
-        ]
-        
-        for error_code in valid_error_codes:
-            # Should not raise exception
-            dto = ProcessingResultDto(
-                success=False,
-                error_message="Test error",
-                error_code=error_code
-            )
-            assert dto.error_code == error_code
-
-    def test_invalid_metadata_type_validation(self):
-        """Test validation with invalid metadata type"""
-        with pytest.raises(ValueError, match="Metadata must be a dictionary"):
-            ProcessingResultDto(
-                success=True,
-                original_text="Test",
-                metadata="invalid"  # String instead of dict
-            )
-
-    def test_has_text_output_property(self):
-        """Test has_text_output property"""
-        # With original text only
-        dto1 = ProcessingResultDto(success=True, original_text="Test")
-        assert dto1.has_text_output is True
-        
-        # With translated text only
-        dto2 = ProcessingResultDto(success=True, translated_text="Prueba")
-        assert dto2.has_text_output is True
-        
-        # With both texts
-        dto3 = ProcessingResultDto(success=True, original_text="Test", translated_text="Prueba")
-        assert dto3.has_text_output is True
-        
-        # With no text
-        dto4 = ProcessingResultDto(success=True, audio_path="/tmp/test.wav")
-        assert dto4.has_text_output is False
-
-    def test_has_audio_output_property(self):
-        """Test has_audio_output property"""
-        # With audio path
-        dto1 = ProcessingResultDto(success=True, audio_path="/tmp/test.wav")
-        assert dto1.has_audio_output is True
-        
-        # Without audio path
-        dto2 = ProcessingResultDto(success=True, original_text="Test")
-        assert dto2.has_audio_output is False
-
-    def test_is_complete_property(self):
-        """Test is_complete property"""
-        # Successful processing
-        dto1 = ProcessingResultDto(success=True, original_text="Test")
-        assert dto1.is_complete is True
-        
-        # Failed processing with error message
-        dto2 = ProcessingResultDto(success=False, error_message="Error")
-        assert dto2.is_complete is True
-        
-        # This shouldn't happen due to validation, but test the logic
-        dto3 = ProcessingResultDto.__new__(ProcessingResultDto)
-        dto3.success = False
-        dto3.error_message = None
-        assert dto3.is_complete is False
-
-    def test_add_metadata_method(self):
-        """Test add_metadata method"""
-        dto = ProcessingResultDto(success=True, original_text="Test")
-        
-        dto.add_metadata("key1", "value1")
-        dto.add_metadata("key2", 123)
-        
-        assert dto.metadata["key1"] == "value1"
-        assert dto.metadata["key2"] == 123
-
-    def test_add_metadata_method_with_none_metadata(self):
-        """Test add_metadata method when metadata is None"""
-        dto = ProcessingResultDto.__new__(ProcessingResultDto)
-        dto.success = True
-        dto.original_text = "Test"
-        dto.metadata = None
-        
-        dto.add_metadata("key", "value")
-        
-        assert dto.metadata == {"key": "value"}
-
-    def test_get_metadata_method(self):
-        """Test get_metadata method"""
-        dto = ProcessingResultDto(
-            success=True,
-            original_text="Test",
-            metadata={"existing_key": "existing_value"}
-        )
-        
-        # Get existing key
-        assert dto.get_metadata("existing_key") == "existing_value"
-        
-        # Get non-existing key with default
-        assert dto.get_metadata("non_existing", "default") == "default"
-        
-        # Get non-existing key without default
-        assert dto.get_metadata("non_existing") is None
-
-    def test_get_metadata_method_with_none_metadata(self):
-        """Test get_metadata method when metadata is None"""
-        dto = ProcessingResultDto.__new__(ProcessingResultDto)
-        dto.success = True
-        dto.original_text = "Test"
-        dto.metadata = None
-        
-        assert dto.get_metadata("key", "default") == "default"
-        assert dto.get_metadata("key") is None
-
-    def test_to_dict_method(self):
-        """Test to_dict method"""
-        test_timestamp = datetime(2023, 1, 1, 12, 0, 0)
-        
-        dto = ProcessingResultDto(
-            success=True,
-            original_text="Hello world",
-            translated_text="Hola mundo",
-            audio_path="/tmp/output.wav",
-            processing_time=5.2,
-            error_message=None,
-            error_code=None,
-            metadata={"correlation_id": "test-123"},
-            timestamp=test_timestamp
-        )
-        
-        result = dto.to_dict()
-        
-        assert result['success'] is True
-        assert result['original_text'] == "Hello world"
-        assert result['translated_text'] == "Hola mundo"
-        assert result['audio_path'] == "/tmp/output.wav"
-        assert result['processing_time'] == 5.2
-        assert result['error_message'] is None
-        assert result['error_code'] is None
-        assert result['metadata'] == {"correlation_id": "test-123"}
-        assert result['timestamp'] == test_timestamp.isoformat()
-        assert result['has_text_output'] is True
-        assert result['has_audio_output'] is True
-        assert result['is_complete'] is True
-
-    def test_to_dict_method_with_none_timestamp(self):
-        """Test to_dict method with None timestamp"""
-        dto = ProcessingResultDto.__new__(ProcessingResultDto)
-        dto.success = True
-        dto.original_text = "Test"
-        dto.translated_text = None
-        dto.audio_path = None
-        dto.processing_time = 0.0
-        dto.error_message = None
-        dto.error_code = None
-        dto.metadata = {}
-        dto.timestamp = None
-        
-        result = dto.to_dict()
-        
-        assert result['timestamp'] is None
-
-    def test_success_result_class_method(self):
-        """Test success_result class method"""
-        result = ProcessingResultDto.success_result(
-            original_text="Hello world",
-            translated_text="Hola mundo",
-            audio_path="/tmp/output.wav",
-            processing_time=3.5,
-            metadata={"test": "value"}
-        )
-        
-        assert isinstance(result, ProcessingResultDto)
-        assert result.success is True
-        assert result.original_text == "Hello world"
-        assert result.translated_text == "Hola mundo"
-        assert result.audio_path == "/tmp/output.wav"
-        assert result.processing_time == 3.5
-        assert result.metadata == {"test": "value"}
-        assert result.error_message is None
-        assert result.error_code is None
-
-    def test_success_result_class_method_with_defaults(self):
-        """Test success_result class method with default values"""
-        result = ProcessingResultDto.success_result(original_text="Test")
-        
-        assert result.success is True
-        assert result.original_text == "Test"
-        assert result.translated_text is None
-        assert result.audio_path is None
-        assert result.processing_time == 0.0
-        assert result.metadata is None
-
-    def test_error_result_class_method(self):
-        """Test error_result class method"""
-        result = ProcessingResultDto.error_result(
-            error_message="Processing failed",
-            error_code="STT_ERROR",
-            processing_time=2.1,
-            metadata={"correlation_id": "test-456"}
-        )
-        
-        assert isinstance(result, ProcessingResultDto)
-        assert result.success is False
-        assert result.error_message == "Processing failed"
-        assert result.error_code == "STT_ERROR"
-        assert result.processing_time == 2.1
-        assert result.metadata == {"correlation_id": "test-456"}
-        assert result.original_text is None
-        assert result.translated_text is None
-        assert result.audio_path is None
-
-    def test_error_result_class_method_with_defaults(self):
-        """Test error_result class method with default values"""
-        result = ProcessingResultDto.error_result("Test error")
-        
-        assert result.success is False
-        assert result.error_message == "Test error"
-        assert result.error_code is None
-        assert result.processing_time == 0.0
-        assert result.metadata is None
-
-    def test_from_dict_class_method(self):
-        """Test from_dict class method"""
-        test_timestamp = datetime(2023, 1, 1, 12, 0, 0)
-        
-        data = {
-            'success': True,
-            'original_text': 'Hello world',
-            'translated_text': 'Hola mundo',
-            'audio_path': '/tmp/output.wav',
-            'processing_time': 5.2,
-            'error_message': None,
-            'error_code': None,
-            'metadata': {'correlation_id': 'test-123'},
-            'timestamp': test_timestamp.isoformat()
-        }
-        
-        dto = ProcessingResultDto.from_dict(data)
-        
-        assert dto.success is True
-        assert dto.original_text == 'Hello world'
-        assert dto.translated_text == 'Hola mundo'
-        assert dto.audio_path == '/tmp/output.wav'
-        assert dto.processing_time == 5.2
-        assert dto.error_message is None
-        assert dto.error_code is None
-        assert dto.metadata == {'correlation_id': 'test-123'}
-        assert dto.timestamp == test_timestamp
-
-    def test_from_dict_class_method_with_z_timestamp(self):
-        """Test from_dict class method with Z-suffixed timestamp"""
-        data = {
-            'success': True,
-            'original_text': 'Test',
-            'timestamp': '2023-01-01T12:00:00Z'
-        }
-        
-        dto = ProcessingResultDto.from_dict(data)
-        
-        assert dto.timestamp == datetime(2023, 1, 1, 12, 0, 0)
-
-    def test_from_dict_class_method_with_defaults(self):
-        """Test from_dict class method with default values"""
-        data = {
-            'success': True,
-            'original_text': 'Test'
-        }
-        
-        dto = ProcessingResultDto.from_dict(data)
-        
-        assert dto.success is True
-        assert dto.original_text == 'Test'
-        assert dto.translated_text is None
-        assert dto.audio_path is None
-        assert dto.processing_time == 0.0
-        assert dto.error_message is None
-        assert dto.error_code is None
-        assert dto.metadata is None
-        assert dto.timestamp is None
-
-    def test_validation_called_on_init(self):
-        """Test that validation is called during initialization"""
-        # This should trigger validation and raise an error
-        with pytest.raises(ValueError):
-            ProcessingResultDto(
-                success="invalid",  # Invalid type
-                original_text="Test"
-            )
-
-    def test_metadata_default_initialization(self):
-        """Test that metadata is initialized to empty dict if None"""
-        dto = ProcessingResultDto(
-            success=True,
-            original_text="Test",
-            metadata=None
-        )
-        
-        assert dto.metadata == {}
-
-    def test_timestamp_default_initialization(self):
-        """Test that timestamp is initialized to current time if None"""
-        before = datetime.utcnow()
-        
-        dto = ProcessingResultDto(
-            success=True,
-            original_text="Test",
-            timestamp=None
-        )
-        
-        after = datetime.utcnow()
-        
-        assert before <= dto.timestamp <= after

tests/unit/application/error_handling/__init__.py

@@ -1 +0,0 @@
-"""Tests for application error handling."""

tests/unit/application/error_handling/test_error_mapper.py

@@ -1,155 +0,0 @@
-"""Tests for error mapper functionality."""
-
-import pytest
-from unittest.mock import Mock
-
-from src.application.error_handling.error_mapper import (
-    ErrorMapper, ErrorMapping, ErrorSeverity, ErrorCategory
-)
-from src.domain.exceptions import (
-    InvalidAudioFormatException,
-    TranslationFailedException,
-    SpeechRecognitionException,
-    SpeechSynthesisException
-)
-
-
-class TestErrorMapper:
-    """Test cases for ErrorMapper."""
-
-    def setup_method(self):
-        """Set up test fixtures."""
-        self.error_mapper = ErrorMapper()
-
-    def test_map_domain_exception(self):
-        """Test mapping of domain exceptions."""
-        exception = InvalidAudioFormatException("Unsupported format: xyz")
-        context = {
-            'file_name': 'test.xyz',
-            'correlation_id': 'test-123'
-        }
-
-        mapping = self.error_mapper.map_exception(exception, context)
-
-        assert mapping.error_code == "INVALID_AUDIO_FORMAT"
-        assert mapping.severity == ErrorSeverity.MEDIUM
-        assert mapping.category == ErrorCategory.VALIDATION
-        assert "supported format" in mapping.user_message.lower()
-        assert len(mapping.recovery_suggestions) > 0
-
-    def test_map_translation_exception(self):
-        """Test mapping of translation exceptions."""
-        exception = TranslationFailedException("Translation service unavailable")
-
-        mapping = self.error_mapper.map_exception(exception)
-
-        assert mapping.error_code == "TRANSLATION_FAILED"
-        assert mapping.severity == ErrorSeverity.HIGH
-        assert mapping.category == ErrorCategory.PROCESSING
-        assert "translation failed" in mapping.user_message.lower()
-
-    def test_map_speech_recognition_exception(self):
-        """Test mapping of speech recognition exceptions."""
-        exception = SpeechRecognitionException("Audio quality too poor")
-        context = {'provider': 'whisper'}
-
-        mapping = self.error_mapper.map_exception(exception, context)
-
-        assert mapping.error_code == "SPEECH_RECOGNITION_FAILED"
-        assert mapping.severity == ErrorSeverity.HIGH
-        assert mapping.category == ErrorCategory.PROCESSING
-        assert any("whisper" in suggestion for suggestion in mapping.recovery_suggestions)
-
-    def test_map_speech_synthesis_exception(self):
-        """Test mapping of speech synthesis exceptions."""
-        exception = SpeechSynthesisException("Voice not available")
-
-        mapping = self.error_mapper.map_exception(exception)
-
-        assert mapping.error_code == "SPEECH_SYNTHESIS_FAILED"
-        assert mapping.severity == ErrorSeverity.HIGH
-        assert mapping.category == ErrorCategory.PROCESSING
-
-    def test_map_unknown_exception(self):
-        """Test mapping of unknown exceptions."""
-        exception = RuntimeError("Unknown error")
-
-        mapping = self.error_mapper.map_exception(exception)
-
-        assert mapping.error_code == "UNKNOWN_ERROR"
-        assert mapping.severity == ErrorSeverity.CRITICAL
-        assert mapping.category == ErrorCategory.SYSTEM
-
-    def test_context_enhancement(self):
-        """Test context enhancement of error mappings."""
-        exception = ValueError("Invalid parameter")
-        context = {
-            'file_name': 'large_file.wav',
-            'file_size': 100 * 1024 * 1024,  # 100MB
-            'correlation_id': 'test-456',
-            'operation': 'audio_processing'
-        }
-
-        mapping = self.error_mapper.map_exception(exception, context)
-
-        assert 'large_file.wav' in mapping.user_message
-        assert 'test-456' in mapping.technical_details
-        assert any("smaller file" in suggestion for suggestion in mapping.recovery_suggestions)
-
-    def test_get_error_code_from_exception(self):
-        """Test getting error code from exception."""
-        exception = TranslationFailedException("Test error")
-
-        error_code = self.error_mapper.get_error_code_from_exception(exception)
-
-        assert error_code == "TRANSLATION_FAILED"
-
-    def test_get_user_message_from_exception(self):
-        """Test getting user message from exception."""
-        exception = InvalidAudioFormatException("Test error")
-
-        message = self.error_mapper.get_user_message_from_exception(exception)
-
-        assert "supported" in message.lower()
-        assert "format" in message.lower()
-
-    def test_get_recovery_suggestions(self):
-        """Test getting recovery suggestions."""
-        exception = SpeechRecognitionException("Test error")
-
-        suggestions = self.error_mapper.get_recovery_suggestions(exception)
-
-        assert len(suggestions) > 0
-        assert any("audio quality" in suggestion.lower() for suggestion in suggestions)
-
-    def test_add_custom_mapping(self):
-        """Test adding custom error mapping."""
-        custom_mapping = ErrorMapping(
-            user_message="Custom error message",
-            error_code="CUSTOM_ERROR",
-            severity=ErrorSeverity.LOW,
-            category=ErrorCategory.VALIDATION
-        )
-
-        self.error_mapper.add_custom_mapping(CustomException, custom_mapping)
-
-        exception = CustomException("Test")
-        mapping = self.error_mapper.map_exception(exception)
-
-        assert mapping.error_code == "CUSTOM_ERROR"
-        assert mapping.user_message == "Custom error message"
-
-    def test_get_all_error_codes(self):
-        """Test getting all error codes."""
-        error_codes = self.error_mapper.get_all_error_codes()
-
-        assert "INVALID_AUDIO_FORMAT" in error_codes
-        assert "TRANSLATION_FAILED" in error_codes
-        assert "SPEECH_RECOGNITION_FAILED" in error_codes
-        assert "SPEECH_SYNTHESIS_FAILED" in error_codes
-        assert "UNKNOWN_ERROR" in error_codes
-
-
-class CustomException(Exception):
-    """Custom exception for testing."""
-    pass

tests/unit/application/error_handling/test_structured_logger.py

@@ -1,298 +0,0 @@
-"""Tests for structured logger functionality."""
-
-import pytest
-import json
-import logging
-from unittest.mock import Mock, patch
-
-from src.application.error_handling.structured_logger import (
-    StructuredLogger, LogContext, JsonFormatter, ContextFormatter,
-    get_structured_logger, set_correlation_id, get_correlation_id,
-    generate_correlation_id
-)
-
-
-class TestLogContext:
-    """Test cases for LogContext."""
-
-    def test_log_context_creation(self):
-        """Test creating log context."""
-        context = LogContext(
-            correlation_id="test-123",
-            operation="test_operation",
-            component="test_component"
-        )
-
-        assert context.correlation_id == "test-123"
-        assert context.operation == "test_operation"
-        assert context.component == "test_component"
-
-    def test_log_context_to_dict(self):
-        """Test converting log context to dictionary."""
-        context = LogContext(
-            correlation_id="test-123",
-            operation="test_operation",
-            metadata={"key": "value"}
-        )
-
-        context_dict = context.to_dict()
-
-        assert context_dict["correlation_id"] == "test-123"
-        assert context_dict["operation"] == "test_operation"
-        assert context_dict["metadata"] == {"key": "value"}
-        assert "user_id" not in context_dict  # None values should be excluded
-
-
-class TestStructuredLogger:
-    """Test cases for StructuredLogger."""
-
-    def setup_method(self):
-        """Set up test fixtures."""
-        self.logger = StructuredLogger("test_logger", enable_json_logging=False)
-
-    def test_logger_creation(self):
-        """Test creating structured logger."""
-        assert self.logger.logger.name == "test_logger"
-        assert not self.logger.enable_json_logging
-
-    def test_debug_logging(self):
-        """Test debug logging."""
-        context = LogContext(correlation_id="test-123", operation="test_op")
-
-        with patch.object(self.logger.logger, 'debug') as mock_debug:
-            self.logger.info("Test debug message", context=context)
-
-            mock_debug.assert_called_once()
-            args, kwargs = mock_debug.call_args
-            assert "Test debug message" in args[0]
-            assert "extra" in kwargs
-
-    def test_info_logging(self):
-        """Test info logging."""
-        context = LogContext(correlation_id="test-123")
-        extra = {"key": "value"}
-
-        with patch.object(self.logger.logger, 'info') as mock_info:
-            self.logger.info("Test info message", context=context, extra=extra)
-
-            mock_info.assert_called_once()
-            args, kwargs = mock_info.call_args
-            assert "Test info message" in args[0]
-            assert kwargs["extra"]["extra"] == extra
-
-    def test_error_logging_with_exception(self):
-        """Test error logging with exception."""
-        context = LogContext(correlation_id="test-123")
-        exception = ValueError("Test error")
-
-        with patch.object(self.logger.logger, 'error') as mock_error:
-            self.logger.error("Test error message", context=context, exception=exception)
-
-            mock_error.assert_called_once()
-            args, kwargs = mock_error.call_args
-            assert "Test error message" in args[0]
-            assert kwargs["extra"]["exception"]["type"] == "ValueError"
-            assert kwargs["extra"]["exception"]["message"] == "Test error"
-
-    def test_log_operation_start(self):
-        """Test logging operation start."""
-        extra = {"param": "value"}
-
-        with patch.object(self.logger.logger, 'info') as mock_info:
-            correlation_id = self.logger.log_operation_start("test_operation", extra=extra)
-
-            assert correlation_id is not None
-            mock_info.assert_called_once()
-            args, kwargs = mock_info.call_args
-            assert "Operation started: test_operation" in args[0]
-
-    def test_log_operation_end_success(self):
-        """Test logging successful operation end."""
-        correlation_id = "test-123"
-
-        with patch.object(self.logger.logger, 'info') as mock_info:
-            self.logger.log_operation_end(
-                "test_operation",
-                correlation_id,
-                success=True,
-                duration=1.5
-            )
-
-            mock_info.assert_called_once()
-            args, kwargs = mock_info.call_args
-            assert "completed successfully" in args[0]
-            assert kwargs["extra"]["extra"]["success"] is True
-            assert kwargs["extra"]["extra"]["duration_seconds"] == 1.5
-
-    def test_log_operation_end_failure(self):
-        """Test logging failed operation end."""
-        correlation_id = "test-123"
-
-        with patch.object(self.logger.logger, 'error') as mock_error:
-            self.logger.log_operation_end(
-                "test_operation",
-                correlation_id,
-                success=False
-            )
-
-            mock_error.assert_called_once()
-            args, kwargs = mock_error.call_args
-            assert "failed" in args[0]
-            assert kwargs["extra"]["extra"]["success"] is False
-
-    def test_log_performance_metric(self):
-        """Test logging performance metric."""
-        context = LogContext(correlation_id="test-123")
-
-        with patch.object(self.logger.logger, 'info') as mock_info:
-            self.logger.log_performance_metric(
-                "response_time",
-                150.5,
-                "ms",
-                context=context
-            )
-
-            mock_info.assert_called_once()
-            args, kwargs = mock_info.call_args
-            assert "Performance metric: response_time=150.5 ms" in args[0]
-            assert kwargs["extra"]["extra"]["metric"]["name"] == "response_time"
-            assert kwargs["extra"]["extra"]["metric"]["value"] == 150.5
-            assert kwargs["extra"]["extra"]["metric"]["unit"] == "ms"
-
-
-class TestJsonFormatter:
-    """Test cases for JsonFormatter."""
-
-    def setup_method(self):
-        """Set up test fixtures."""
-        self.formatter = JsonFormatter()
-
-    def test_format_log_record(self):
-        """Test formatting log record as JSON."""
-        record = logging.LogRecord(
-            name="test_logger",
-            level=logging.INFO,
-            pathname="test.py",
-            lineno=10,
-            msg="Test message",
-            args=(),
-            exc_info=None
-        )
-
-        # Add extra data
-        record.extra = {
-            "correlation_id": "test-123",
-            "operation": "test_op"
-        }
-
-        formatted = self.formatter.format(record)
-
-        # Should be valid JSON
-        log_data = json.loads(formatted)
-        assert log_data["message"] == "Test message"
-        assert log_data["level"] == "INFO"
-        assert log_data["correlation_id"] == "test-123"
-        assert log_data["operation"] == "test_op"
-
-    def test_format_error_handling(self):
-        """Test formatter error handling."""
-        record = logging.LogRecord(
-            name="test_logger",
-            level=logging.INFO,
-            pathname="test.py",
-            lineno=10,
-            msg="Test message",
-            args=(),
-            exc_info=None
-        )
-
-        # Add problematic extra data that can't be JSON serialized
-        record.extra = {
-            "correlation_id": "test-123",
-            "problematic_data": object()  # Can't be JSON serialized
-        }
-
-        formatted = self.formatter.format(record)
-
-        # Should still work and include error message
-        assert "Test message" in formatted
-
-
-class TestContextFormatter:
-    """Test cases for ContextFormatter."""
-
-    def setup_method(self):
-        """Set up test fixtures."""
-        self.formatter = ContextFormatter()
-
-    def test_format_with_correlation_id(self):
-        """Test formatting with correlation ID."""
-        record = logging.LogRecord(
-            name="test_logger",
-            level=logging.INFO,
-            pathname="test.py",
-            lineno=10,
-            msg="Test message",
-            args=(),
-            exc_info=None
-        )
-
-        record.extra = {"correlation_id": "test-123"}
-
-        formatted = self.formatter.format(record)
-
-        assert "[test-123]" in formatted
-        assert "Test message" in formatted
-
-    def test_format_with_operation(self):
-        """Test formatting with operation context."""
-        record = logging.LogRecord(
-            name="test_logger",
-            level=logging.INFO,
-            pathname="test.py",
-            lineno=10,
-            msg="Test message",
-            args=(),
-            exc_info=None
-        )
-
-        record.extra = {
-            "correlation_id": "test-123",
-            "operation": "test_operation"
-        }
-
-        formatted = self.formatter.format(record)
-
-        assert "[test_operation]" in formatted
-        assert "Test message" in formatted
-
-
-class TestUtilityFunctions:
-    """Test cases for utility functions."""
-
-    def test_get_structured_logger(self):
-        """Test getting structured logger."""
-        logger = get_structured_logger("test_logger")
-
-        assert isinstance(logger, StructuredLogger)
-        assert logger.logger.name == "test_logger"
-
-    def test_correlation_id_context(self):
-        """Test correlation ID context management."""
-        # Initially should be None
-        assert get_correlation_id() is None
-
-        # Set correlation ID
-        set_correlation_id("test-123")
-        assert get_correlation_id() == "test-123"
-
-    def test_generate_correlation_id(self):
-        """Test generating correlation ID."""
-        correlation_id = generate_correlation_id()
-
-        assert correlation_id is not None
-        assert len(correlation_id) > 0
-
-        # Should generate different IDs
-        another_id = generate_correlation_id()
-        assert correlation_id != another_id

tests/unit/application/services/__init__.py

@@ -1 +0,0 @@
-"""Unit tests for application services"""

tests/unit/application/services/test_audio_processing_service.py

@@ -1,475 +0,0 @@
-"""Unit tests for AudioProcessingApplicationService"""
-
-import pytest
-import tempfile
-import os
-import time
-from unittest.mock import Mock, MagicMock, patch, call
-from contextlib import contextmanager
-
-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.domain.models.audio_content import AudioContent
-from src.domain.models.text_content import TextContent
-from src.domain.models.translation_request import TranslationRequest
-from src.domain.models.speech_synthesis_request import SpeechSynthesisRequest
-from src.domain.models.voice_settings import VoiceSettings
-from src.domain.exceptions import (
-    AudioProcessingException,
-    SpeechRecognitionException,
-    TranslationFailedException,
-    SpeechSynthesisException
-)
-from src.infrastructure.config.app_config import AppConfig
-from src.infrastructure.config.dependency_container import DependencyContainer
-
-
-class TestAudioProcessingApplicationService:
-    """Test cases for AudioProcessingApplicationService"""
-
-    @pytest.fixture
-    def mock_container(self):
-        """Create mock dependency container"""
-        container = Mock(spec=DependencyContainer)
-        
-        # Mock providers
-        mock_stt_provider = Mock()
-        mock_translation_provider = Mock()
-        mock_tts_provider = Mock()
-        
-        container.get_stt_provider.return_value = mock_stt_provider
-        container.get_translation_provider.return_value = mock_translation_provider
-        container.get_tts_provider.return_value = mock_tts_provider
-        
-        return container
-
-    @pytest.fixture
-    def mock_config(self):
-        """Create mock application config"""
-        config = Mock(spec=AppConfig)
-        
-        # Mock configuration methods
-        config.get_logging_config.return_value = {
-            'level': 'INFO',
-            'enable_file_logging': False,
-            'log_file_path': '/tmp/test.log',
-            'format': '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
-        }
-        
-        config.get_processing_config.return_value = {
-            'max_file_size_mb': 100,
-            'supported_audio_formats': ['wav', 'mp3', 'flac', 'ogg', 'm4a'],
-            'temp_dir': '/tmp',
-            'cleanup_temp_files': True,
-            'processing_timeout_seconds': 300
-        }
-        
-        config.get_stt_config.return_value = {
-            'preferred_providers': ['whisper-small', 'whisper-medium']
-        }
-        
-        config.get_tts_config.return_value = {
-            'preferred_providers': ['chatterbox']
-        }
-        
-        return config
-
-    @pytest.fixture
-    def sample_audio_upload(self):
-        """Create sample audio upload DTO"""
-        return AudioUploadDto(
-            filename="test_audio.wav",
-            content=b"fake_audio_content_" + b"x" * 1000,  # 1KB+ of fake audio
-            content_type="audio/wav"
-        )
-
-    @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",
-            voice="chatterbox",
-            speed=1.0,
-            source_language="en"
-        )
-
-    @pytest.fixture
-    def service(self, mock_container, mock_config):
-        """Create AudioProcessingApplicationService instance"""
-        mock_container.resolve.return_value = mock_config
-        return AudioProcessingApplicationService(mock_container, mock_config)
-
-    def test_initialization(self, mock_container, mock_config):
-        """Test service initialization"""
-        service = AudioProcessingApplicationService(mock_container, mock_config)
-        
-        assert service._container == mock_container
-        assert service._config == mock_config
-        assert service._temp_files == {}
-        assert service._error_mapper is not None
-        assert service._recovery_manager is not None
-
-    def test_initialization_without_config(self, mock_container, mock_config):
-        """Test service initialization without explicit config"""
-        mock_container.resolve.return_value = mock_config
-        
-        service = AudioProcessingApplicationService(mock_container)
-        
-        assert service._container == mock_container
-        assert service._config == mock_config
-        mock_container.resolve.assert_called_once_with(AppConfig)
-
-    @patch('src.application.services.audio_processing_service.get_structured_logger')
-    def test_setup_logging_success(self, mock_logger, service, mock_config):
-        """Test successful logging setup"""
-        mock_config.get_logging_config.return_value = {
-            'level': 'DEBUG',
-            'enable_file_logging': True,
-            'log_file_path': '/tmp/test.log',
-            'format': '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
-        }
-        
-        service._setup_logging()
-        
-        # Verify logging configuration was retrieved
-        mock_config.get_logging_config.assert_called_once()
-
-    @patch('src.application.services.audio_processing_service.get_structured_logger')
-    def test_setup_logging_failure(self, mock_logger, service, mock_config):
-        """Test logging setup failure handling"""
-        mock_config.get_logging_config.side_effect = Exception("Config error")
-        
-        # Should not raise exception
-        service._setup_logging()
-        
-        # Warning should be logged
-        mock_logger.return_value.warning.assert_called_once()
-
-    def test_validate_request_success(self, service, sample_processing_request):
-        """Test successful request validation"""
-        # Should not raise exception
-        service._validate_request(sample_processing_request)
-
-    def test_validate_request_invalid_type(self, service):
-        """Test request validation with invalid type"""
-        with pytest.raises(ValueError, match="Request must be a ProcessingRequestDto instance"):
-            service._validate_request("invalid_request")
-
-    def test_validate_request_file_too_large(self, service, sample_processing_request, mock_config):
-        """Test request validation with file too large"""
-        mock_config.get_processing_config.return_value['max_file_size_mb'] = 0.001  # Very small limit
-        
-        with pytest.raises(ValueError, match="Audio file too large"):
-            service._validate_request(sample_processing_request)
-
-    def test_validate_request_unsupported_format(self, service, sample_processing_request, mock_config):
-        """Test request validation with unsupported format"""
-        sample_processing_request.audio.filename = "test.xyz"
-        mock_config.get_processing_config.return_value['supported_audio_formats'] = ['wav', 'mp3']
-        
-        with pytest.raises(ValueError, match="Unsupported audio format"):
-            service._validate_request(sample_processing_request)
-
-    @patch('os.makedirs')
-    @patch('shutil.rmtree')
-    def test_create_temp_directory(self, mock_rmtree, mock_makedirs, service):
-        """Test temporary directory creation and cleanup"""
-        correlation_id = "test-123"
-        
-        with service._create_temp_directory(correlation_id) as temp_dir:
-            assert correlation_id in temp_dir
-            mock_makedirs.assert_called_once()
-        
-        # Cleanup should be called
-        mock_rmtree.assert_called_once()
-
-    @patch('builtins.open', create=True)
-    def test_convert_upload_to_audio_content_success(self, mock_open, service, sample_audio_upload):
-        """Test successful audio upload conversion"""
-        temp_dir = "/tmp/test"
-        mock_file = MagicMock()
-        mock_open.return_value.__enter__.return_value = mock_file
-        
-        result = service._convert_upload_to_audio_content(sample_audio_upload, temp_dir)
-        
-        assert isinstance(result, AudioContent)
-        assert result.data == sample_audio_upload.content
-        assert result.format == "wav"
-        mock_file.write.assert_called_once_with(sample_audio_upload.content)
-
-    @patch('builtins.open', side_effect=IOError("File error"))
-    def test_convert_upload_to_audio_content_failure(self, mock_open, service, sample_audio_upload):
-        """Test audio upload conversion failure"""
-        temp_dir = "/tmp/test"
-        
-        with pytest.raises(AudioProcessingException, match="Failed to process uploaded audio"):
-            service._convert_upload_to_audio_content(sample_audio_upload, temp_dir)
-
-    def test_perform_speech_recognition_success(self, service, mock_container):
-        """Test successful speech recognition"""
-        audio = AudioContent(data=b"audio", format="wav", sample_rate=16000, duration=1.0)
-        model = "whisper-small"
-        correlation_id = "test-123"
-        
-        # Mock STT provider
-        mock_stt_provider = Mock()
-        expected_text = TextContent(text="Hello world", language="en")
-        mock_stt_provider.transcribe.return_value = expected_text
-        mock_container.get_stt_provider.return_value = mock_stt_provider
-        
-        result = service._perform_speech_recognition(audio, model, correlation_id)
-        
-        assert result == expected_text
-        mock_container.get_stt_provider.assert_called_once_with(model)
-        mock_stt_provider.transcribe.assert_called_once_with(audio, model)
-
-    def test_perform_speech_recognition_failure(self, service, mock_container):
-        """Test speech recognition failure"""
-        audio = AudioContent(data=b"audio", format="wav", sample_rate=16000, duration=1.0)
-        model = "whisper-small"
-        correlation_id = "test-123"
-        
-        # Mock STT provider to raise exception
-        mock_stt_provider = Mock()
-        mock_stt_provider.transcribe.side_effect = Exception("STT failed")
-        mock_container.get_stt_provider.return_value = mock_stt_provider
-        
-        with pytest.raises(SpeechRecognitionException, match="Speech recognition failed"):
-            service._perform_speech_recognition(audio, model, correlation_id)
-
-    def test_perform_translation_success(self, service, mock_container):
-        """Test successful translation"""
-        text = TextContent(text="Hello world", language="en")
-        source_language = "en"
-        target_language = "es"
-        correlation_id = "test-123"
-        
-        # Mock translation provider
-        mock_translation_provider = Mock()
-        expected_text = TextContent(text="Hola mundo", language="es")
-        mock_translation_provider.translate.return_value = expected_text
-        mock_container.get_translation_provider.return_value = mock_translation_provider
-        
-        result = service._perform_translation(text, source_language, target_language, correlation_id)
-        
-        assert result == expected_text
-        mock_container.get_translation_provider.assert_called_once()
-        mock_translation_provider.translate.assert_called_once()
-
-    def test_perform_translation_failure(self, service, mock_container):
-        """Test translation failure"""
-        text = TextContent(text="Hello world", language="en")
-        source_language = "en"
-        target_language = "es"
-        correlation_id = "test-123"
-        
-        # Mock translation provider to raise exception
-        mock_translation_provider = Mock()
-        mock_translation_provider.translate.side_effect = Exception("Translation failed")
-        mock_container.get_translation_provider.return_value = mock_translation_provider
-        
-        with pytest.raises(TranslationFailedException, match="Translation failed"):
-            service._perform_translation(text, source_language, target_language, correlation_id)
-
-    @patch('builtins.open', create=True)
-    def test_perform_speech_synthesis_success(self, mock_open, service, mock_container):
-        """Test successful speech synthesis"""
-        text = TextContent(text="Hola mundo", language="es")
-        voice = "chatterbox"
-        speed = 1.0
-        language = "es"
-        temp_dir = "/tmp/test"
-        correlation_id = "test-123"
-        
-        # Mock TTS provider
-        mock_tts_provider = Mock()
-        mock_audio = AudioContent(data=b"synthesized_audio", format="wav", sample_rate=22050, duration=2.0)
-        mock_tts_provider.synthesize.return_value = mock_audio
-        mock_container.get_tts_provider.return_value = mock_tts_provider
-        
-        # Mock file operations
-        mock_file = MagicMock()
-        mock_open.return_value.__enter__.return_value = mock_file
-        
-        result = service._perform_speech_synthesis(text, voice, speed, language, temp_dir, correlation_id)
-        
-        assert correlation_id in result
-        assert result.endswith(".wav")
-        mock_container.get_tts_provider.assert_called_once_with(voice)
-        mock_tts_provider.synthesize.assert_called_once()
-        mock_file.write.assert_called_once_with(mock_audio.data)
-
-    def test_perform_speech_synthesis_failure(self, service, mock_container):
-        """Test speech synthesis failure"""
-        text = TextContent(text="Hola mundo", language="es")
-        voice = "chatterbox"
-        speed = 1.0
-        language = "es"
-        temp_dir = "/tmp/test"
-        correlation_id = "test-123"
-        
-        # Mock TTS provider to raise exception
-        mock_tts_provider = Mock()
-        mock_tts_provider.synthesize.side_effect = Exception("TTS failed")
-        mock_container.get_tts_provider.return_value = mock_tts_provider
-        
-        with pytest.raises(SpeechSynthesisException, match="Speech synthesis failed"):
-            service._perform_speech_synthesis(text, voice, speed, language, temp_dir, correlation_id)
-
-    def test_get_error_code_from_exception(self, service):
-        """Test error code mapping from exceptions"""
-        assert service._get_error_code_from_exception(SpeechRecognitionException("test")) == 'STT_ERROR'
-        assert service._get_error_code_from_exception(TranslationFailedException("test")) == 'TRANSLATION_ERROR'
-        assert service._get_error_code_from_exception(SpeechSynthesisException("test")) == 'TTS_ERROR'
-        assert service._get_error_code_from_exception(ValueError("test")) == 'VALIDATION_ERROR'
-        assert service._get_error_code_from_exception(Exception("test")) == 'SYSTEM_ERROR'
-
-    @patch('os.path.exists')
-    @patch('os.remove')
-    def test_cleanup_temp_files_success(self, mock_remove, mock_exists, service):
-        """Test successful temporary file cleanup"""
-        service._temp_files = {
-            "/tmp/file1.wav": "/tmp/file1.wav",
-            "/tmp/file2.wav": "/tmp/file2.wav"
-        }
-        mock_exists.return_value = True
-        
-        service._cleanup_temp_files()
-        
-        assert service._temp_files == {}
-        assert mock_remove.call_count == 2
-
-    @patch('os.path.exists')
-    @patch('os.remove', side_effect=OSError("Permission denied"))
-    def test_cleanup_temp_files_failure(self, mock_remove, mock_exists, service):
-        """Test temporary file cleanup with failures"""
-        service._temp_files = {"/tmp/file1.wav": "/tmp/file1.wav"}
-        mock_exists.return_value = True
-        
-        # Should not raise exception
-        service._cleanup_temp_files()
-        
-        # File should still be removed from tracking
-        assert service._temp_files == {}
-
-    def test_get_processing_status(self, service):
-        """Test processing status retrieval"""
-        correlation_id = "test-123"
-        
-        result = service.get_processing_status(correlation_id)
-        
-        assert result['correlation_id'] == correlation_id
-        assert 'status' in result
-        assert 'message' in result
-
-    def test_get_supported_configurations(self, service):
-        """Test supported configurations retrieval"""
-        result = service.get_supported_configurations()
-        
-        assert 'asr_models' in result
-        assert 'voices' in result
-        assert 'languages' in result
-        assert 'audio_formats' in result
-        assert 'max_file_size_mb' in result
-        assert 'speed_range' in result
-        
-        # Verify expected values
-        assert 'whisper-small' in result['asr_models']
-        assert 'chatterbox' in result['voices']
-        assert 'en' in result['languages']
-
-    def test_cleanup(self, service):
-        """Test service cleanup"""
-        service._temp_files = {"/tmp/test.wav": "/tmp/test.wav"}
-        
-        with patch.object(service, '_cleanup_temp_files') as mock_cleanup:
-            service.cleanup()
-            mock_cleanup.assert_called_once()
-
-    def test_context_manager(self, service):
-        """Test service as context manager"""
-        with patch.object(service, 'cleanup') as mock_cleanup:
-            with service as svc:
-                assert svc == service
-            mock_cleanup.assert_called_once()
-
-    @patch('src.application.services.audio_processing_service.time.time')
-    @patch.object(AudioProcessingApplicationService, '_create_temp_directory')
-    @patch.object(AudioProcessingApplicationService, '_convert_upload_to_audio_content')
-    @patch.object(AudioProcessingApplicationService, '_perform_speech_recognition_with_recovery')
-    @patch.object(AudioProcessingApplicationService, '_perform_translation_with_recovery')
-    @patch.object(AudioProcessingApplicationService, '_perform_speech_synthesis_with_recovery')
-    def test_process_audio_pipeline_success(self, mock_tts, mock_translation, mock_stt, 
-                                          mock_convert, mock_temp_dir, mock_time, 
-                                          service, sample_processing_request):
-        """Test successful audio processing pipeline"""
-        # Setup mocks
-        mock_time.side_effect = [0.0, 5.0]  # Start and end times
-        mock_temp_dir.return_value.__enter__.return_value = "/tmp/test"
-        mock_temp_dir.return_value.__exit__.return_value = None
-        
-        mock_audio = AudioContent(data=b"audio", format="wav", sample_rate=16000, duration=1.0)
-        mock_convert.return_value = mock_audio
-        
-        mock_original_text = TextContent(text="Hello world", language="en")
-        mock_stt.return_value = mock_original_text
-        
-        mock_translated_text = TextContent(text="Hola mundo", language="es")
-        mock_translation.return_value = mock_translated_text
-        
-        mock_tts.return_value = "/tmp/test/output_123.wav"
-        
-        with patch.object(service, '_validate_request'):
-            result = service.process_audio_pipeline(sample_processing_request)
-        
-        # Verify result
-        assert isinstance(result, ProcessingResultDto)
-        assert result.success is True
-        assert result.original_text == "Hello world"
-        assert result.translated_text == "Hola mundo"
-        assert result.audio_path == "/tmp/test/output_123.wav"
-        assert result.processing_time == 5.0
-
-    @patch('src.application.services.audio_processing_service.time.time')
-    def test_process_audio_pipeline_validation_error(self, mock_time, service, sample_processing_request):
-        """Test audio processing pipeline with validation error"""
-        mock_time.side_effect = [0.0, 1.0]
-        
-        with patch.object(service, '_validate_request', side_effect=ValueError("Invalid request")):
-            result = service.process_audio_pipeline(sample_processing_request)
-        
-        # Verify error result
-        assert isinstance(result, ProcessingResultDto)
-        assert result.success is False
-        assert "Invalid request" in result.error_message
-        assert result.processing_time == 1.0
-
-    @patch('src.application.services.audio_processing_service.time.time')
-    def test_process_audio_pipeline_domain_exception(self, mock_time, service, sample_processing_request):
-        """Test audio processing pipeline with domain exception"""
-        mock_time.side_effect = [0.0, 2.0]
-        
-        with patch.object(service, '_validate_request'):
-            with patch.object(service, '_create_temp_directory', side_effect=SpeechRecognitionException("STT failed")):
-                result = service.process_audio_pipeline(sample_processing_request)
-        
-        # Verify error result
-        assert isinstance(result, ProcessingResultDto)
-        assert result.success is False
-        assert result.error_message is not None
-        assert result.processing_time == 2.0
-
-    def test_recovery_methods_exist(self, service):
-        """Test that recovery methods exist and are callable"""
-        # These methods should exist for error recovery
-        assert hasattr(service, '_perform_speech_recognition_with_recovery')
-        assert hasattr(service, '_perform_translation_with_recovery')
-        assert hasattr(service, '_perform_speech_synthesis_with_recovery')
-        
-        assert callable(service._perform_speech_recognition_with_recovery)
-        assert callable(service._perform_translation_with_recovery)
-        assert callable(service._perform_speech_synthesis_with_recovery)

tests/unit/application/services/test_configuration_service.py

@@ -1,572 +0,0 @@
-"""Unit tests for ConfigurationApplicationService"""
-
-import pytest
-import os
-import json
-from unittest.mock import Mock, MagicMock, patch, mock_open
-
-from src.application.services.configuration_service import (
-    ConfigurationApplicationService,
-    ConfigurationException
-)
-from src.infrastructure.config.app_config import AppConfig
-from src.infrastructure.config.dependency_container import DependencyContainer
-
-
-class TestConfigurationApplicationService:
-    """Test cases for ConfigurationApplicationService"""
-
-    @pytest.fixture
-    def mock_container(self):
-        """Create mock dependency container"""
-        container = Mock(spec=DependencyContainer)
-        return container
-
-    @pytest.fixture
-    def mock_config(self):
-        """Create mock application config"""
-        config = Mock(spec=AppConfig)
-        
-        # Mock configuration methods
-        config.get_tts_config.return_value = {
-            'preferred_providers': ['chatterbox'],
-            'default_speed': 1.0,
-            'default_language': 'en',
-            'enable_streaming': False,
-            'max_text_length': 5000
-        }
-        
-        config.get_stt_config.return_value = {
-            'preferred_providers': ['whisper', 'parakeet'],
-            'default_model': 'whisper',
-            'chunk_length_s': 30,
-            'batch_size': 16,
-            'enable_vad': True
-        }
-        
-        config.get_translation_config.return_value = {
-            'default_provider': 'nllb',
-            'model_name': 'nllb-200-3.3B',
-            'max_chunk_length': 512,
-            'batch_size': 8,
-            'cache_translations': True
-        }
-        
-        config.get_processing_config.return_value = {
-            'temp_dir': '/tmp',
-            'cleanup_temp_files': True,
-            'max_file_size_mb': 100,
-            'supported_audio_formats': ['wav', 'mp3', 'flac'],
-            'processing_timeout_seconds': 300
-        }
-        
-        config.get_logging_config.return_value = {
-            'level': 'INFO',
-            'enable_file_logging': False,
-            'log_file_path': '/tmp/app.log',
-            'format': '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
-        }
-        
-        # Mock config objects for attribute access
-        config.tts = Mock()
-        config.stt = Mock()
-        config.translation = Mock()
-        config.processing = Mock()
-        config.logging = Mock()
-        
-        return config
-
-    @pytest.fixture
-    def service(self, mock_container, mock_config):
-        """Create ConfigurationApplicationService instance"""
-        mock_container.resolve.return_value = mock_config
-        return ConfigurationApplicationService(mock_container, mock_config)
-
-    def test_initialization(self, mock_container, mock_config):
-        """Test service initialization"""
-        service = ConfigurationApplicationService(mock_container, mock_config)
-        
-        assert service._container == mock_container
-        assert service._config == mock_config
-        assert service._error_mapper is not None
-
-    def test_initialization_without_config(self, mock_container, mock_config):
-        """Test service initialization without explicit config"""
-        mock_container.resolve.return_value = mock_config
-        
-        service = ConfigurationApplicationService(mock_container)
-        
-        assert service._container == mock_container
-        assert service._config == mock_config
-        mock_container.resolve.assert_called_once_with(AppConfig)
-
-    def test_get_current_configuration_success(self, service, mock_config):
-        """Test successful current configuration retrieval"""
-        result = service.get_current_configuration()
-        
-        assert 'tts' in result
-        assert 'stt' in result
-        assert 'translation' in result
-        assert 'processing' in result
-        assert 'logging' in result
-        
-        # Verify all config methods were called
-        mock_config.get_tts_config.assert_called_once()
-        mock_config.get_stt_config.assert_called_once()
-        mock_config.get_translation_config.assert_called_once()
-        mock_config.get_processing_config.assert_called_once()
-        mock_config.get_logging_config.assert_called_once()
-
-    def test_get_current_configuration_failure(self, service, mock_config):
-        """Test current configuration retrieval failure"""
-        mock_config.get_tts_config.side_effect = Exception("Config error")
-        
-        with pytest.raises(ConfigurationException, match="Failed to retrieve configuration"):
-            service.get_current_configuration()
-
-    def test_get_tts_configuration_success(self, service, mock_config):
-        """Test successful TTS configuration retrieval"""
-        result = service.get_tts_configuration()
-        
-        assert result['preferred_providers'] == ['chatterbox']
-        assert result['default_speed'] == 1.0
-        mock_config.get_tts_config.assert_called_once()
-
-    def test_get_tts_configuration_failure(self, service, mock_config):
-        """Test TTS configuration retrieval failure"""
-        mock_config.get_tts_config.side_effect = Exception("TTS config error")
-        
-        with pytest.raises(ConfigurationException, match="Failed to retrieve TTS configuration"):
-            service.get_tts_configuration()
-
-    def test_get_stt_configuration_success(self, service, mock_config):
-        """Test successful STT configuration retrieval"""
-        result = service.get_stt_configuration()
-        
-        assert result['preferred_providers'] == ['whisper', 'parakeet']
-        assert result['default_model'] == 'whisper'
-        mock_config.get_stt_config.assert_called_once()
-
-    def test_get_stt_configuration_failure(self, service, mock_config):
-        """Test STT configuration retrieval failure"""
-        mock_config.get_stt_config.side_effect = Exception("STT config error")
-        
-        with pytest.raises(ConfigurationException, match="Failed to retrieve STT configuration"):
-            service.get_stt_configuration()
-
-    def test_get_translation_configuration_success(self, service, mock_config):
-        """Test successful translation configuration retrieval"""
-        result = service.get_translation_configuration()
-        
-        assert result['default_provider'] == 'nllb'
-        assert result['model_name'] == 'nllb-200-3.3B'
-        mock_config.get_translation_config.assert_called_once()
-
-    def test_get_translation_configuration_failure(self, service, mock_config):
-        """Test translation configuration retrieval failure"""
-        mock_config.get_translation_config.side_effect = Exception("Translation config error")
-        
-        with pytest.raises(ConfigurationException, match="Failed to retrieve translation configuration"):
-            service.get_translation_configuration()
-
-    def test_get_processing_configuration_success(self, service, mock_config):
-        """Test successful processing configuration retrieval"""
-        result = service.get_processing_configuration()
-        
-        assert result['temp_dir'] == '/tmp'
-        assert result['max_file_size_mb'] == 100
-        mock_config.get_processing_config.assert_called_once()
-
-    def test_get_processing_configuration_failure(self, service, mock_config):
-        """Test processing configuration retrieval failure"""
-        mock_config.get_processing_config.side_effect = Exception("Processing config error")
-        
-        with pytest.raises(ConfigurationException, match="Failed to retrieve processing configuration"):
-            service.get_processing_configuration()
-
-    def test_get_logging_configuration_success(self, service, mock_config):
-        """Test successful logging configuration retrieval"""
-        result = service.get_logging_configuration()
-        
-        assert result['level'] == 'INFO'
-        assert result['enable_file_logging'] is False
-        mock_config.get_logging_config.assert_called_once()
-
-    def test_get_logging_configuration_failure(self, service, mock_config):
-        """Test logging configuration retrieval failure"""
-        mock_config.get_logging_config.side_effect = Exception("Logging config error")
-        
-        with pytest.raises(ConfigurationException, match="Failed to retrieve logging configuration"):
-            service.get_logging_configuration()
-
-    def test_update_tts_configuration_success(self, service, mock_config):
-        """Test successful TTS configuration update"""
-        updates = {
-            'default_speed': 1.5,
-            'enable_streaming': True
-        }
-        
-        result = service.update_tts_configuration(updates)
-        
-        # Verify setattr was called for valid attributes
-        assert hasattr(mock_config.tts, 'default_speed')
-        assert hasattr(mock_config.tts, 'enable_streaming')
-        
-        # Verify updated config was returned
-        mock_config.get_tts_config.assert_called()
-
-    def test_update_tts_configuration_validation_error(self, service):
-        """Test TTS configuration update with validation error"""
-        updates = {
-            'default_speed': 5.0  # Invalid speed > 3.0
-        }
-        
-        with pytest.raises(ConfigurationException, match="default_speed must be between 0.1 and 3.0"):
-            service.update_tts_configuration(updates)
-
-    def test_update_stt_configuration_success(self, service, mock_config):
-        """Test successful STT configuration update"""
-        updates = {
-            'chunk_length_s': 60,
-            'enable_vad': False
-        }
-        
-        result = service.update_stt_configuration(updates)
-        
-        # Verify setattr was called for valid attributes
-        assert hasattr(mock_config.stt, 'chunk_length_s')
-        assert hasattr(mock_config.stt, 'enable_vad')
-        
-        # Verify updated config was returned
-        mock_config.get_stt_config.assert_called()
-
-    def test_update_stt_configuration_validation_error(self, service):
-        """Test STT configuration update with validation error"""
-        updates = {
-            'chunk_length_s': -10  # Invalid negative value
-        }
-        
-        with pytest.raises(ConfigurationException, match="chunk_length_s must be a positive integer"):
-            service.update_stt_configuration(updates)
-
-    def test_update_translation_configuration_success(self, service, mock_config):
-        """Test successful translation configuration update"""
-        updates = {
-            'max_chunk_length': 1024,
-            'cache_translations': False
-        }
-        
-        result = service.update_translation_configuration(updates)
-        
-        # Verify setattr was called for valid attributes
-        assert hasattr(mock_config.translation, 'max_chunk_length')
-        assert hasattr(mock_config.translation, 'cache_translations')
-        
-        # Verify updated config was returned
-        mock_config.get_translation_config.assert_called()
-
-    def test_update_translation_configuration_validation_error(self, service):
-        """Test translation configuration update with validation error"""
-        updates = {
-            'max_chunk_length': 0  # Invalid zero value
-        }
-        
-        with pytest.raises(ConfigurationException, match="max_chunk_length must be a positive integer"):
-            service.update_translation_configuration(updates)
-
-    def test_update_processing_configuration_success(self, service, mock_config):
-        """Test successful processing configuration update"""
-        updates = {
-            'max_file_size_mb': 200,
-            'cleanup_temp_files': False
-        }
-        
-        with patch('pathlib.Path.mkdir'):
-            result = service.update_processing_configuration(updates)
-        
-        # Verify setattr was called for valid attributes
-        assert hasattr(mock_config.processing, 'max_file_size_mb')
-        assert hasattr(mock_config.processing, 'cleanup_temp_files')
-        
-        # Verify updated config was returned
-        mock_config.get_processing_config.assert_called()
-
-    def test_update_processing_configuration_validation_error(self, service):
-        """Test processing configuration update with validation error"""
-        updates = {
-            'max_file_size_mb': -50  # Invalid negative value
-        }
-        
-        with pytest.raises(ConfigurationException, match="max_file_size_mb must be a positive integer"):
-            service.update_processing_configuration(updates)
-
-    def test_validate_tts_updates_valid(self, service):
-        """Test TTS updates validation with valid data"""
-        updates = {
-            'preferred_providers': ['chatterbox'],
-            'default_speed': 1.5,
-            'default_language': 'es',
-            'enable_streaming': True,
-            'max_text_length': 10000
-        }
-        
-        # Should not raise exception
-        service._validate_tts_updates(updates)
-
-    def test_validate_tts_updates_invalid_provider(self, service):
-        """Test TTS updates validation with invalid provider"""
-        updates = {
-            'preferred_providers': ['invalid_provider']
-        }
-        
-        with pytest.raises(ConfigurationException, match="Invalid TTS provider"):
-            service._validate_tts_updates(updates)
-
-    def test_validate_tts_updates_invalid_speed(self, service):
-        """Test TTS updates validation with invalid speed"""
-        updates = {
-            'default_speed': 5.0  # Too high
-        }
-        
-        with pytest.raises(ConfigurationException, match="default_speed must be between 0.1 and 3.0"):
-            service._validate_tts_updates(updates)
-
-    def test_validate_stt_updates_valid(self, service):
-        """Test STT updates validation with valid data"""
-        updates = {
-            'preferred_providers': ['whisper', 'parakeet'],
-            'default_model': 'whisper',
-            'chunk_length_s': 45,
-            'batch_size': 32,
-            'enable_vad': False
-        }
-        
-        # Should not raise exception
-        service._validate_stt_updates(updates)
-
-    def test_validate_stt_updates_invalid_provider(self, service):
-        """Test STT updates validation with invalid provider"""
-        updates = {
-            'preferred_providers': ['invalid_stt']
-        }
-        
-        with pytest.raises(ConfigurationException, match="Invalid STT provider"):
-            service._validate_stt_updates(updates)
-
-    def test_validate_translation_updates_valid(self, service):
-        """Test translation updates validation with valid data"""
-        updates = {
-            'default_provider': 'nllb',
-            'model_name': 'nllb-200-1.3B',
-            'max_chunk_length': 256,
-            'batch_size': 4,
-            'cache_translations': False
-        }
-        
-        # Should not raise exception
-        service._validate_translation_updates(updates)
-
-    def test_validate_processing_updates_valid(self, service):
-        """Test processing updates validation with valid data"""
-        updates = {
-            'temp_dir': '/tmp/test',
-            'cleanup_temp_files': True,
-            'max_file_size_mb': 150,
-            'supported_audio_formats': ['wav', 'mp3'],
-            'processing_timeout_seconds': 600
-        }
-        
-        with patch('pathlib.Path.mkdir'):
-            # Should not raise exception
-            service._validate_processing_updates(updates)
-
-    def test_validate_processing_updates_invalid_format(self, service):
-        """Test processing updates validation with invalid audio format"""
-        updates = {
-            'supported_audio_formats': ['wav', 'invalid_format']
-        }
-        
-        with pytest.raises(ConfigurationException, match="Invalid audio format"):
-            service._validate_processing_updates(updates)
-
-    def test_save_configuration_to_file_success(self, service, mock_config):
-        """Test successful configuration save to file"""
-        file_path = "/tmp/config.json"
-        
-        service.save_configuration_to_file(file_path)
-        
-        mock_config.save_configuration.assert_called_once_with(file_path)
-
-    def test_save_configuration_to_file_failure(self, service, mock_config):
-        """Test configuration save to file failure"""
-        file_path = "/tmp/config.json"
-        mock_config.save_configuration.side_effect = Exception("Save failed")
-        
-        with pytest.raises(ConfigurationException, match="Failed to save configuration"):
-            service.save_configuration_to_file(file_path)
-
-    @patch('os.path.exists')
-    def test_load_configuration_from_file_success(self, mock_exists, service, mock_container):
-        """Test successful configuration load from file"""
-        file_path = "/tmp/config.json"
-        mock_exists.return_value = True
-        
-        with patch('src.infrastructure.config.app_config.AppConfig') as mock_app_config:
-            new_config = Mock()
-            mock_app_config.return_value = new_config
-            
-            result = service.load_configuration_from_file(file_path)
-            
-            # Verify new config was created and registered
-            mock_app_config.assert_called_once_with(config_file=file_path)
-            mock_container.register_singleton.assert_called_once_with(AppConfig, new_config)
-
-    @patch('os.path.exists')
-    def test_load_configuration_from_file_not_found(self, mock_exists, service):
-        """Test configuration load from non-existent file"""
-        file_path = "/tmp/nonexistent.json"
-        mock_exists.return_value = False
-        
-        with pytest.raises(ConfigurationException, match="Configuration file not found"):
-            service.load_configuration_from_file(file_path)
-
-    def test_reload_configuration_success(self, service, mock_config):
-        """Test successful configuration reload"""
-        result = service.reload_configuration()
-        
-        mock_config.reload_configuration.assert_called_once()
-        assert 'tts' in result
-
-    def test_reload_configuration_failure(self, service, mock_config):
-        """Test configuration reload failure"""
-        mock_config.reload_configuration.side_effect = Exception("Reload failed")
-        
-        with pytest.raises(ConfigurationException, match="Failed to reload configuration"):
-            service.reload_configuration()
-
-    def test_get_provider_availability(self, service, mock_container):
-        """Test provider availability check"""
-        # Mock factories
-        mock_tts_factory = Mock()
-        mock_stt_factory = Mock()
-        mock_translation_factory = Mock()
-        
-        mock_container.resolve.side_effect = [mock_tts_factory, mock_stt_factory, mock_translation_factory]
-        
-        # Mock successful provider creation
-        mock_tts_factory.create_provider.return_value = Mock()
-        mock_stt_factory.create_provider.return_value = Mock()
-        mock_translation_factory.get_default_provider.return_value = Mock()
-        
-        result = service.get_provider_availability()
-        
-        assert 'tts' in result
-        assert 'stt' in result
-        assert 'translation' in result
-        
-        # All providers should be available
-        assert all(result['tts'].values())
-        assert all(result['stt'].values())
-        assert result['translation']['nllb'] is True
-
-    def test_get_system_info(self, service, mock_config):
-        """Test system information retrieval"""
-        mock_config.config_file = "/tmp/config.json"
-        mock_config.processing.temp_dir = "/tmp"
-        mock_config.logging.level = "INFO"
-        mock_config.processing.supported_audio_formats = ['wav', 'mp3']
-        mock_config.processing.max_file_size_mb = 100
-        mock_config.processing.processing_timeout_seconds = 300
-        
-        with patch.object(service, 'get_provider_availability', return_value={}):
-            result = service.get_system_info()
-        
-        assert result['config_file'] == "/tmp/config.json"
-        assert result['temp_directory'] == "/tmp"
-        assert result['log_level'] == "INFO"
-        assert 'supported_languages' in result
-        assert 'supported_audio_formats' in result
-        assert 'max_file_size_mb' in result
-
-    def test_validate_configuration_success(self, service, mock_config):
-        """Test successful configuration validation"""
-        # Mock valid configuration
-        mock_config.get_tts_config.return_value = {
-            'default_speed': 1.0,
-            'max_text_length': 5000
-        }
-        mock_config.get_stt_config.return_value = {
-            'chunk_length_s': 30,
-            'batch_size': 16
-        }
-        mock_config.get_processing_config.return_value = {
-            'temp_dir': '/tmp',
-            'max_file_size_mb': 100
-        }
-        mock_config.get_logging_config.return_value = {
-            'level': 'INFO'
-        }
-        
-        with patch('os.path.exists', return_value=True):
-            result = service.validate_configuration()
-        
-        # Should have no issues
-        assert all(len(issues) == 0 for issues in result.values())
-
-    def test_validate_configuration_with_issues(self, service, mock_config):
-        """Test configuration validation with issues"""
-        # Mock invalid configuration
-        mock_config.get_tts_config.return_value = {
-            'default_speed': 5.0,  # Invalid
-            'max_text_length': -100  # Invalid
-        }
-        mock_config.get_stt_config.return_value = {
-            'chunk_length_s': -10,  # Invalid
-            'batch_size': 0  # Invalid
-        }
-        mock_config.get_processing_config.return_value = {
-            'temp_dir': '/nonexistent',  # Invalid
-            'max_file_size_mb': -50  # Invalid
-        }
-        mock_config.get_logging_config.return_value = {
-            'level': 'INVALID'  # Invalid
-        }
-        
-        with patch('os.path.exists', return_value=False):
-            result = service.validate_configuration()
-        
-        # Should have issues in each category
-        assert len(result['tts']) > 0
-        assert len(result['stt']) > 0
-        assert len(result['processing']) > 0
-        assert len(result['logging']) > 0
-
-    def test_reset_to_defaults_success(self, service, mock_container):
-        """Test successful configuration reset to defaults"""
-        with patch('src.infrastructure.config.app_config.AppConfig') as mock_app_config:
-            default_config = Mock()
-            mock_app_config.return_value = default_config
-            
-            result = service.reset_to_defaults()
-            
-            # Verify new default config was created and registered
-            mock_app_config.assert_called_once_with()
-            mock_container.register_singleton.assert_called_once_with(AppConfig, default_config)
-
-    def test_reset_to_defaults_failure(self, service):
-        """Test configuration reset to defaults failure"""
-        with patch('src.infrastructure.config.app_config.AppConfig', side_effect=Exception("Reset failed")):
-            with pytest.raises(ConfigurationException, match="Failed to reset configuration"):
-                service.reset_to_defaults()
-
-    def test_cleanup(self, service):
-        """Test service cleanup"""
-        # Should not raise exception
-        service.cleanup()
-
-    def test_context_manager(self, service):
-        """Test service as context manager"""
-        with patch.object(service, 'cleanup') as mock_cleanup:
-            with service as svc:
-                assert svc == service
-            mock_cleanup.assert_called_once()

tests/unit/domain/interfaces/__init__.py

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

tests/unit/domain/interfaces/test_audio_processing.py

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

tests/unit/domain/interfaces/test_speech_recognition.py

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

tests/unit/domain/interfaces/test_speech_synthesis.py

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

tests/unit/domain/interfaces/test_translation.py

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

tests/unit/domain/models/test_audio_chunk.py

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

tests/unit/domain/models/test_audio_content.py

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

tests/unit/domain/models/test_processing_result.py

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

tests/unit/domain/models/test_speech_synthesis_request.py

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

tests/unit/domain/models/test_text_content.py

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

tests/unit/domain/models/test_translation_request.py

@@ -1,243 +0,0 @@
-"""Unit tests for TranslationRequest value object."""
-
-import pytest
-from src.domain.models.translation_request import TranslationRequest
-from src.domain.models.text_content import TextContent
-
-
-class TestTranslationRequest:
-    """Test cases for TranslationRequest value object."""
-
-    @pytest.fixture
-    def sample_text_content(self):
-        """Sample text content for testing."""
-        return TextContent(
-            text="Hello, world!",
-            language="en"
-        )
-
-    def test_valid_translation_request_creation(self, sample_text_content):
-        """Test creating valid TranslationRequest instance."""
-        request = TranslationRequest(
-            source_text=sample_text_content,
-            target_language="es",
-            source_language="en"
-        )
-
-        assert request.source_text == sample_text_content
-        assert request.target_language == "es"
-        assert request.source_language == "en"
-        assert request.effective_source_language == "en"
-        assert request.is_auto_detect_source is False
-
-    def test_translation_request_without_source_language(self, sample_text_content):
-        """Test creating TranslationRequest without explicit source language."""
-        request = TranslationRequest(
-            source_text=sample_text_content,
-            target_language="es"
-        )
-
-        assert request.source_language is None
-        assert request.effective_source_language == "en"  # From TextContent
-        assert request.is_auto_detect_source is True
-
-    def test_non_text_content_source_raises_error(self):
-        """Test that non-TextContent source raises TypeError."""
-        with pytest.raises(TypeError, match="Source text must be a TextContent instance"):
-            TranslationRequest(
-                source_text="not a TextContent",  # type: ignore
-                target_language="es"
-            )
-
-    def test_non_string_target_language_raises_error(self, sample_text_content):
-        """Test that non-string target language raises TypeError."""
-        with pytest.raises(TypeError, match="Target language must be a string"):
-            TranslationRequest(
-                source_text=sample_text_content,
-                target_language=123  # type: ignore
-            )
-
-    def test_empty_target_language_raises_error(self, sample_text_content):
-        """Test that empty target language raises ValueError."""
-        with pytest.raises(ValueError, match="Target language cannot be empty"):
-            TranslationRequest(
-                source_text=sample_text_content,
-                target_language=""
-            )
-
-    def test_whitespace_target_language_raises_error(self, sample_text_content):
-        """Test that whitespace-only target language raises ValueError."""
-        with pytest.raises(ValueError, match="Target language cannot be empty"):
-            TranslationRequest(
-                source_text=sample_text_content,
-                target_language="   "
-            )
-
-    def test_invalid_target_language_format_raises_error(self, sample_text_content):
-        """Test that invalid target language format raises ValueError."""
-        invalid_codes = ["e", "ENG", "en-us", "en-USA", "123", "en_US"]
-
-        for code in invalid_codes:
-            with pytest.raises(ValueError, match="Invalid target language code format"):
-                TranslationRequest(
-                    source_text=sample_text_content,
-                    target_language=code
-                )
-
-    def test_valid_target_language_codes(self, sample_text_content):
-        """Test valid target language code formats."""
-        valid_codes = ["es", "fr", "de", "zh", "ja", "en-US", "fr-FR", "zh-CN"]
-
-        for code in valid_codes:
-            request = TranslationRequest(
-                source_text=sample_text_content,
-                target_language=code
-            )
-            assert request.target_language == code
-
-    def test_non_string_source_language_raises_error(self, sample_text_content):
-        """Test that non-string source language raises TypeError."""
-        with pytest.raises(TypeError, match="Source language must be a string"):
-            TranslationRequest(
-                source_text=sample_text_content,
-                target_language="es",
-                source_language=123  # type: ignore
-            )
-
-    def test_empty_source_language_raises_error(self, sample_text_content):
-        """Test that empty source language raises ValueError."""
-        with pytest.raises(ValueError, match="Source language cannot be empty string"):
-            TranslationRequest(
-                source_text=sample_text_content,
-                target_language="es",
-                source_language=""
-            )
-
-    def test_whitespace_source_language_raises_error(self, sample_text_content):
-        """Test that whitespace-only source language raises ValueError."""
-        with pytest.raises(ValueError, match="Source language cannot be empty string"):
-            TranslationRequest(
-                source_text=sample_text_content,
-                target_language="es",
-                source_language="   "
-            )
-
-    def test_invalid_source_language_format_raises_error(self, sample_text_content):
-        """Test that invalid source language format raises ValueError."""
-        invalid_codes = ["e", "ENG", "en-us", "en-USA", "123", "en_US"]
-
-        for code in invalid_codes:
-            with pytest.raises(ValueError, match="Invalid source language code format"):
-                TranslationRequest(
-                    source_text=sample_text_content,
-                    target_language="es",
-                    source_language=code
-                )
-
-    def test_same_source_and_target_language_explicit_raises_error(self, sample_text_content):
-        """Test that same explicit source and target language raises ValueError."""
-        with pytest.raises(ValueError, match="Source and target languages cannot be the same"):
-            TranslationRequest(
-                source_text=sample_text_content,
-                target_language="en",
-                source_language="en"
-            )
-
-    def test_same_source_and_target_language_implicit_raises_error(self):
-        """Test that same implicit source and target language raises ValueError."""
-        text_content = TextContent(text="Hello", language="en")
-
-        with pytest.raises(ValueError, match="Source and target languages cannot be the same"):
-            TranslationRequest(
-                source_text=text_content,
-                target_language="en"  # Same as text_content.language
-            )
-
-    def test_text_length_property(self, sample_text_content):
-        """Test text_length property."""
-        request = TranslationRequest(
-            source_text=sample_text_content,
-            target_language="es"
-        )
-
-        assert request.text_length == len(sample_text_content.text)
-
-    def test_word_count_property(self, sample_text_content):
-        """Test word_count property."""
-        request = TranslationRequest(
-            source_text=sample_text_content,
-            target_language="es"
-        )
-
-        assert request.word_count == sample_text_content.word_count
-
-    def test_with_target_language_method(self, sample_text_content):
-        """Test with_target_language method creates new instance."""
-        original = TranslationRequest(
-            source_text=sample_text_content,
-            target_language="es",
-            source_language="en"
-        )
-
-        new_request = original.with_target_language("fr")
-
-        assert new_request.target_language == "fr"
-        assert new_request.source_text == original.source_text
-        assert new_request.source_language == original.source_language
-        assert new_request is not original  # Different instances
-
-    def test_with_source_language_method(self, sample_text_content):
-        """Test with_source_language method creates new instance."""
-        original = TranslationRequest(
-            source_text=sample_text_content,
-            target_language="es",
-            source_language="en"
-        )
-
-        new_request = original.with_source_language("de")
-
-        assert new_request.source_language == "de"
-        assert new_request.target_language == original.target_language
-        assert new_request.source_text == original.source_text
-        assert new_request is not original  # Different instances
-
-    def test_with_source_language_none(self, sample_text_content):
-        """Test with_source_language method with None value."""
-        original = TranslationRequest(
-            source_text=sample_text_content,
-            target_language="es",
-            source_language="en"
-        )
-
-        new_request = original.with_source_language(None)
-        assert new_request.source_language is None
-        assert new_request.is_auto_detect_source is True
-
-    def test_translation_request_is_immutable(self, sample_text_content):
-        """Test that TranslationRequest is immutable (frozen dataclass)."""
-        request = TranslationRequest(
-            source_text=sample_text_content,
-            target_language="es"
-        )
-
-        with pytest.raises(AttributeError):
-            request.target_language = "fr"  # type: ignore
-
-    def test_effective_source_language_with_explicit_source(self, sample_text_content):
-        """Test effective_source_language with explicit source language."""
-        request = TranslationRequest(
-            source_text=sample_text_content,
-            target_language="es",
-            source_language="de"  # Different from text_content.language
-        )
-
-        assert request.effective_source_language == "de"
-
-    def test_effective_source_language_with_implicit_source(self, sample_text_content):
-        """Test effective_source_language with implicit source language."""
-        request = TranslationRequest(
-            source_text=sample_text_content,
-            target_language="es"
-        )
-
-        assert request.effective_source_language == sample_text_content.language

tests/unit/domain/models/test_voice_settings.py

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

tests/unit/domain/services/__init__.py

@@ -1 +0,0 @@
-"""Domain services tests package."""

tests/unit/domain/services/test_audio_processing_service.py

@@ -1,297 +0,0 @@
-"""Tests for AudioProcessingService."""
-
-import pytest
-from unittest.mock import Mock, MagicMock
-from src.domain.services.audio_processing_service import AudioProcessingService
-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.models.translation_request import TranslationRequest
-from src.domain.models.speech_synthesis_request import SpeechSynthesisRequest
-from src.domain.exceptions import (
-    AudioProcessingException,
-    SpeechRecognitionException,
-    TranslationFailedException,
-    SpeechSynthesisException
-)
-
-
-class TestAudioProcessingService:
-    """Test cases for AudioProcessingService."""
-
-    @pytest.fixture
-    def mock_stt_service(self):
-        """Mock speech recognition service."""
-        return Mock()
-
-    @pytest.fixture
-    def mock_translation_service(self):
-        """Mock translation service."""
-        return Mock()
-
-    @pytest.fixture
-    def mock_tts_service(self):
-        """Mock speech synthesis service."""
-        return Mock()
-
-    @pytest.fixture
-    def audio_processing_service(self, mock_stt_service, mock_translation_service, mock_tts_service):
-        """AudioProcessingService instance with mocked dependencies."""
-        return AudioProcessingService(
-            speech_recognition_service=mock_stt_service,
-            translation_service=mock_translation_service,
-            speech_synthesis_service=mock_tts_service
-        )
-
-    @pytest.fixture
-    def sample_audio(self):
-        """Sample audio content for testing."""
-        return AudioContent(
-            data=b"fake_audio_data",
-            format="wav",
-            sample_rate=22050,
-            duration=10.0,
-            filename="test.wav"
-        )
-
-    @pytest.fixture
-    def sample_voice_settings(self):
-        """Sample voice settings for testing."""
-        return VoiceSettings(
-            voice_id="test_voice",
-            speed=1.0,
-            language="es"
-        )
-
-    @pytest.fixture
-    def sample_text_content(self):
-        """Sample text content for testing."""
-        return TextContent(
-            text="Hello world",
-            language="en"
-        )
-
-    def test_successful_pipeline_processing(
-        self,
-        audio_processing_service,
-        mock_stt_service,
-        mock_translation_service,
-        mock_tts_service,
-        sample_audio,
-        sample_voice_settings,
-        sample_text_content
-    ):
-        """Test successful processing through the complete pipeline."""
-        # Arrange
-        original_text = TextContent(text="Hello world", language="en")
-        translated_text = TextContent(text="Hola mundo", language="es")
-        output_audio = AudioContent(
-            data=b"synthesized_audio",
-            format="wav",
-            sample_rate=22050,
-            duration=5.0
-        )
-
-        mock_stt_service.transcribe.return_value = original_text
-        mock_translation_service.translate.return_value = translated_text
-        mock_tts_service.synthesize.return_value = output_audio
-
-        # Act
-        result = audio_processing_service.process_audio_pipeline(
-            audio=sample_audio,
-            target_language="es",
-            voice_settings=sample_voice_settings
-        )
-
-        # Assert
-        assert result.success is True
-        assert result.original_text == original_text
-        assert result.translated_text == translated_text
-        assert result.audio_output == output_audio
-        assert result.error_message is None
-        assert result.processing_time >= 0
-
-        # Verify service calls
-        mock_stt_service.transcribe.assert_called_once_with(sample_audio, "whisper-base")
-        mock_translation_service.translate.assert_called_once()
-        mock_tts_service.synthesize.assert_called_once()
-
-    def test_no_translation_needed_same_language(
-        self,
-        audio_processing_service,
-        mock_stt_service,
-        mock_translation_service,
-        mock_tts_service,
-        sample_audio
-    ):
-        """Test pipeline when no translation is needed (same language)."""
-        # Arrange
-        original_text = TextContent(text="Hola mundo", language="es")
-        voice_settings = VoiceSettings(voice_id="test_voice", speed=1.0, language="es")
-        output_audio = AudioContent(
-            data=b"synthesized_audio",
-            format="wav",
-            sample_rate=22050,
-            duration=5.0
-        )
-
-        mock_stt_service.transcribe.return_value = original_text
-        mock_tts_service.synthesize.return_value = output_audio
-
-        # Act
-        result = audio_processing_service.process_audio_pipeline(
-            audio=sample_audio,
-            target_language="es",
-            voice_settings=voice_settings
-        )
-
-        # Assert
-        assert result.success is True
-        assert result.original_text == original_text
-        assert result.translated_text == original_text  # Same as original
-        assert result.audio_output == output_audio
-
-        # Translation service should not be called
-        mock_translation_service.translate.assert_not_called()
-
-    def test_validation_error_none_audio(self, audio_processing_service, sample_voice_settings):
-        """Test validation error when audio is None."""
-        # Act
-        result = audio_processing_service.process_audio_pipeline(
-            audio=None,
-            target_language="es",
-            voice_settings=sample_voice_settings
-        )
-
-        # Assert
-        assert result.success is False
-        assert "Audio content cannot be None" in result.error_message
-
-    def test_validation_error_empty_target_language(self, audio_processing_service, sample_audio, sample_voice_settings):
-        """Test validation error when target language is empty."""
-        # Act
-        result = audio_processing_service.process_audio_pipeline(
-            audio=sample_audio,
-            target_language="",
-            voice_settings=sample_voice_settings
-        )
-
-        # Assert
-        assert result.success is False
-        assert "Target language cannot be empty" in result.error_message
-
-    def test_validation_error_language_mismatch(self, audio_processing_service, sample_audio):
-        """Test validation error when voice settings language doesn't match target language."""
-        # Arrange
-        voice_settings = VoiceSettings(voice_id="test_voice", speed=1.0, language="en")
-
-        # Act
-        result = audio_processing_service.process_audio_pipeline(
-            audio=sample_audio,
-            target_language="es",
-            voice_settings=voice_settings
-        )
-
-        # Assert
-        assert result.success is False
-        assert "Voice settings language (en) must match target language (es)" in result.error_message
-
-    def test_validation_error_audio_too_long(self, audio_processing_service, sample_voice_settings):
-        """Test validation error when audio is too long."""
-        # Arrange
-        long_audio = AudioContent(
-            data=b"fake_audio_data",
-            format="wav",
-            sample_rate=22050,
-            duration=400.0  # Exceeds 300s limit
-        )
-
-        # Act
-        result = audio_processing_service.process_audio_pipeline(
-            audio=long_audio,
-            target_language="es",
-            voice_settings=sample_voice_settings
-        )
-
-        # Assert
-        assert result.success is False
-        assert "exceeds maximum allowed duration" in result.error_message
-
-    def test_stt_failure_handling(
-        self,
-        audio_processing_service,
-        mock_stt_service,
-        sample_audio,
-        sample_voice_settings
-    ):
-        """Test handling of STT service failure."""
-        # Arrange
-        mock_stt_service.transcribe.side_effect = Exception("STT service unavailable")
-
-        # Act
-        result = audio_processing_service.process_audio_pipeline(
-            audio=sample_audio,
-            target_language="es",
-            voice_settings=sample_voice_settings
-        )
-
-        # Assert
-        assert result.success is False
-        assert "Speech recognition failed" in result.error_message
-        assert result.processing_time >= 0
-
-    def test_translation_failure_handling(
-        self,
-        audio_processing_service,
-        mock_stt_service,
-        mock_translation_service,
-        sample_audio,
-        sample_voice_settings
-    ):
-        """Test handling of translation service failure."""
-        # Arrange
-        original_text = TextContent(text="Hello world", language="en")
-        mock_stt_service.transcribe.return_value = original_text
-        mock_translation_service.translate.side_effect = Exception("Translation service unavailable")
-
-        # Act
-        result = audio_processing_service.process_audio_pipeline(
-            audio=sample_audio,
-            target_language="es",
-            voice_settings=sample_voice_settings
-        )
-
-        # Assert
-        assert result.success is False
-        assert "Translation failed" in result.error_message
-        assert result.processing_time >= 0
-
-    def test_tts_failure_handling(
-        self,
-        audio_processing_service,
-        mock_stt_service,
-        mock_translation_service,
-        mock_tts_service,
-        sample_audio,
-        sample_voice_settings
-    ):
-        """Test handling of TTS service failure."""
-        # Arrange
-        original_text = TextContent(text="Hello world", language="en")
-        translated_text = TextContent(text="Hola mundo", language="es")
-
-        mock_stt_service.transcribe.return_value = original_text
-        mock_translation_service.translate.return_value = translated_text
-        mock_tts_service.synthesize.side_effect = Exception("TTS service unavailable")
-
-        # Act
-        result = audio_processing_service.process_audio_pipeline(
-            audio=sample_audio,
-            target_language="es",
-            voice_settings=sample_voice_settings
-        )
-
-        # Assert
-        assert result.success is False
-        assert "Speech synthesis failed" in result.error_message
-        assert result.processing_time >= 0

tests/unit/domain/test_exceptions.py

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

tests/unit/infrastructure/__init__.py

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

tests/unit/infrastructure/base/__init__.py

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

tests/unit/infrastructure/base/test_stt_provider_base.py

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

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

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

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

tests/unit/infrastructure/config/test_dependency_container.py

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

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

tests/unit/infrastructure/factories/test_stt_provider_factory.py

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

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

@@ -1,232 +0,0 @@
-"""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 'chatterbox' in self.factory._providers
-    
-    @patch('src.infrastructure.tts.provider_factory.ChatterboxTTSProvider')
-    def test_register_default_providers_chatterbox(self, mock_chatterbox):
-        """Test registration of chatterbox provider."""
-        factory = TTSProviderFactory()
-        
-        assert 'chatterbox' in factory._providers
-        assert factory._providers['chatterbox'] == mock_chatterbox
-    
-    @patch('src.infrastructure.tts.chatterbox_provider.ChatterboxTTSProvider', side_effect=ImportError("Not available"))
-    def test_register_default_providers_chatterbox_unavailable(self, mock_chatterbox):
-        """Test handling when Chatterbox provider is not available."""
-        with pytest.raises(SpeechSynthesisException, match="No TTS providers available"):
-            TTSProviderFactory()
-    
-    @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', {'chatterbox': MockTTSProvider})
-    def test_create_provider_with_lang_code(self):
-        """Test creating provider with language code."""
-        with patch.object(MockTTSProvider, 'is_available', return_value=True):
-            provider = self.factory.create_provider('chatterbox', 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