Create unit tests for application layer

tests/unit/application/__init__.py

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

tests/unit/application/dtos/__init__.py

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

tests/unit/application/dtos/test_audio_upload_dto.py

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

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

@@ -0,0 +1,383 @@
+"""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="kokoro",
+            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="dia"
+        )
+        
+        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="cosyvoice2",
+            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="kokoro"
+            )
+
+    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="kokoro"
+            )
+
+    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="kokoro"
+            )
+
+    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="kokoro"
+            )
+            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="kokoro"
+            )
+
+    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="kokoro"
+            )
+
+    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="kokoro",
+                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="kokoro",
+                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 = ['kokoro', 'dia', 'cosyvoice2', 'dummy']
+        
+        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="kokoro",
+                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="kokoro",
+                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="kokoro",
+                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="kokoro",
+                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="kokoro",
+            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="kokoro",
+            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="kokoro"
+        )
+        
+        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="kokoro",
+            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'] == "kokoro"
+        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="kokoro"
+            )
+
+    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="kokoro",
+            additional_params=None
+        )
+        
+        assert dto.additional_params == {}

tests/unit/application/dtos/test_processing_result_dto.py

@@ -0,0 +1,436 @@
+"""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/services/__init__.py

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

tests/unit/application/services/test_audio_processing_service.py

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

@@ -0,0 +1,572 @@
+"""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': ['kokoro', 'dia'],
+            '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'] == ['kokoro', 'dia']
+        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': ['kokoro', 'dia'],
+            '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()