Update application entry point and cleanup

.vercel/project.json

@@ -1 +0,0 @@
-{"projectName":"trae_5altap2j"}

app.py

@@ -16,7 +16,6 @@ logger = logging.getLogger(__name__)
 
 import streamlit as st
 import os
-import time
 from typing import Optional
 
 # Import application services and DTOs

test_dependency_injection.py

@@ -1,314 +0,0 @@
-#!/usr/bin/env python3
-"""Test script for dependency injection and configuration setup."""
-
-import sys
-import os
-import logging
-from pathlib import Path
-
-# Add src to path for imports
-sys.path.insert(0, str(Path(__file__).parent / "src"))
-
-from infrastructure.config.container_setup import (
-    create_configured_container,
-    get_service_registry_info,
-    initialize_global_container,
-    get_global_container,
-    cleanup_global_container
-)
-from infrastructure.config.app_config import AppConfig
-from infrastructure.config.dependency_container import DependencyContainer
-from application.services.audio_processing_service import AudioProcessingApplicationService
-from application.services.configuration_service import ConfigurationApplicationService
-
-
-def test_configuration_loading():
-    """Test configuration loading from file and environment."""
-    print("=" * 60)
-    print("Testing Configuration Loading")
-    print("=" * 60)
-
-    try:
-        # Test default configuration
-        print("\n1. Testing default configuration...")
-        config = AppConfig()
-        print(f"✓ Default config loaded successfully")
-        print(f"  - TTS preferred providers: {config.tts.preferred_providers}")
-        print(f"  - STT default model: {config.stt.default_model}")
-        print(f"  - Translation provider: {config.translation.default_provider}")
-        print(f"  - Temp directory: {config.processing.temp_dir}")
-        print(f"  - Log level: {config.logging.level}")
-
-        # Test configuration from file
-        print("\n2. Testing configuration from file...")
-        config_file = "config.example.json"
-        if os.path.exists(config_file):
-            config_from_file = AppConfig(config_file=config_file)
-            print(f"✓ Config loaded from {config_file}")
-            print(f"  - TTS preferred providers: {config_from_file.tts.preferred_providers}")
-            print(f"  - Processing timeout: {config_from_file.processing.processing_timeout_seconds}s")
-        else:
-            print(f"⚠ Config file {config_file} not found, skipping file test")
-
-        # Test environment variable override
-        print("\n3. Testing environment variable override...")
-        os.environ['TTS_DEFAULT_SPEED'] = '1.5'
-        os.environ['LOG_LEVEL'] = 'DEBUG'
-
-        config_with_env = AppConfig()
-        print(f"✓ Config with environment overrides loaded")
-        print(f"  - TTS default speed: {config_with_env.tts.default_speed}")
-        print(f"  - Log level: {config_with_env.logging.level}")
-
-        # Clean up environment
-        del os.environ['TTS_DEFAULT_SPEED']
-        del os.environ['LOG_LEVEL']
-
-        return True
-
-    except Exception as e:
-        print(f"✗ Configuration loading failed: {e}")
-        return False
-
-
-def test_dependency_container():
-    """Test dependency container setup and service resolution."""
-    print("\n" + "=" * 60)
-    print("Testing Dependency Container")
-    print("=" * 60)
-
-    try:
-        # Test container creation
-        print("\n1. Testing container creation...")
-        container = create_configured_container()
-        print("✓ Container created successfully")
-
-        # Test service registration info
-        print("\n2. Testing service registry...")
-        registry_info = get_service_registry_info(container)
-        print("✓ Service registry information retrieved")
-        print(f"  - Registered services: {len(registry_info['registered_services'])}")
-
-        for service_name, lifetime in registry_info['registered_services'].items():
-            print(f"    • {service_name}: {lifetime}")
-
-        # Test provider availability
-        print("\n3. Testing provider availability...")
-        provider_info = registry_info['provider_availability']
-        print(f"  - Available TTS providers: {provider_info['tts_providers']}")
-        print(f"  - Available STT providers: {provider_info['stt_providers']}")
-        print(f"  - Available translation providers: {provider_info['translation_providers']}")
-
-        # Test service resolution
-        print("\n4. Testing service resolution...")
-
-        # Resolve configuration
-        config = container.resolve(AppConfig)
-        print("✓ AppConfig resolved successfully")
-
-        # Resolve application services
-        audio_service = container.resolve(AudioProcessingApplicationService)
-        print("✓ AudioProcessingApplicationService resolved successfully")
-
-        config_service = container.resolve(ConfigurationApplicationService)
-        print("✓ ConfigurationApplicationService resolved successfully")
-
-        # Test provider services
-        tts_provider = container.get_tts_provider()
-        print(f"✓ TTS provider resolved: {tts_provider.__class__.__name__}")
-
-        stt_provider = container.get_stt_provider()
-        print(f"✓ STT provider resolved: {stt_provider.__class__.__name__}")
-
-        translation_provider = container.get_translation_provider()
-        print(f"✓ Translation provider resolved: {translation_provider.__class__.__name__}")
-
-        # Test scoped services
-        print("\n5. Testing scoped services...")
-        with container.create_scope() as scope:
-            scoped_audio_service = scope.resolve(AudioProcessingApplicationService)
-            print("✓ Scoped AudioProcessingApplicationService resolved")
-
-        # Cleanup
-        container.cleanup()
-        print("✓ Container cleanup completed")
-
-        return True
-
-    except Exception as e:
-        print(f"✗ Dependency container test failed: {e}")
-        import traceback
-        traceback.print_exc()
-        return False
-
-
-def test_global_container():
-    """Test global container management."""
-    print("\n" + "=" * 60)
-    print("Testing Global Container Management")
-    print("=" * 60)
-
-    try:
-        # Test global container initialization
-        print("\n1. Testing global container initialization...")
-        global_container = initialize_global_container()
-        print("✓ Global container initialized")
-
-        # Test global container access
-        print("\n2. Testing global container access...")
-        retrieved_container = get_global_container()
-        print("✓ Global container retrieved")
-
-        assert global_container is retrieved_container, "Global container instances should be the same"
-        print("✓ Global container instance consistency verified")
-
-        # Test service resolution through global container
-        print("\n3. Testing service resolution through global container...")
-        config = retrieved_container.resolve(AppConfig)
-        print("✓ Configuration resolved through global container")
-
-        # Test global container cleanup
-        print("\n4. Testing global container cleanup...")
-        cleanup_global_container()
-        print("✓ Global container cleaned up")
-
-        return True
-
-    except Exception as e:
-        print(f"✗ Global container test failed: {e}")
-        return False
-
-
-def test_configuration_service():
-    """Test configuration application service."""
-    print("\n" + "=" * 60)
-    print("Testing Configuration Application Service")
-    print("=" * 60)
-
-    try:
-        # Create container
-        container = create_configured_container()
-
-        # Get configuration service
-        print("\n1. Testing configuration service resolution...")
-        config_service = container.resolve(ConfigurationApplicationService)
-        print("✓ Configuration service resolved")
-
-        # Test getting current configuration
-        print("\n2. Testing configuration retrieval...")
-        current_config = config_service.get_current_configuration()
-        print("✓ Current configuration retrieved")
-        print(f"  - Configuration sections: {list(current_config.keys())}")
-
-        # Test TTS configuration
-        print("\n3. Testing TTS configuration...")
-        tts_config = config_service.get_tts_configuration()
-        print(f"✓ TTS configuration: {len(tts_config)} settings")
-
-        # Test configuration updates
-        print("\n4. Testing configuration updates...")
-        updated_tts = config_service.update_tts_configuration({
-            'default_speed': 1.2,
-            'enable_streaming': False
-        })
-        print("✓ TTS configuration updated")
-        print(f"  - New default speed: {updated_tts['default_speed']}")
-        print(f"  - Streaming enabled: {updated_tts['enable_streaming']}")
-
-        # Test provider availability
-        print("\n5. Testing provider availability check...")
-        availability = config_service.get_provider_availability()
-        print("✓ Provider availability checked")
-        for category, providers in availability.items():
-            print(f"  - {category.upper()}: {providers}")
-
-        # Test system info
-        print("\n6. Testing system information...")
-        system_info = config_service.get_system_info()
-        print("✓ System information retrieved")
-        print(f"  - Supported languages: {len(system_info['supported_languages'])}")
-        print(f"  - Supported audio formats: {system_info['supported_audio_formats']}")
-
-        # Test configuration validation
-        print("\n7. Testing configuration validation...")
-        validation_issues = config_service.validate_configuration()
-        print("✓ Configuration validation completed")
-
-        total_issues = sum(len(issues) for issues in validation_issues.values())
-        if total_issues == 0:
-            print("  - No validation issues found")
-        else:
-            print(f"  - Found {total_issues} validation issues")
-            for category, issues in validation_issues.items():
-                if issues:
-                    print(f"    • {category}: {issues}")
-
-        # Cleanup
-        container.cleanup()
-
-        return True
-
-    except Exception as e:
-        print(f"✗ Configuration service test failed: {e}")
-        import traceback
-        traceback.print_exc()
-        return False
-
-
-def main():
-    """Run all tests."""
-    print("Dependency Injection and Configuration Test Suite")
-    print("=" * 60)
-
-    # Configure basic logging
-    logging.basicConfig(
-        level=logging.WARNING,  # Reduce noise during testing
-        format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
-    )
-
-    tests = [
-        ("Configuration Loading", test_configuration_loading),
-        ("Dependency Container", test_dependency_container),
-        ("Global Container Management", test_global_container),
-        ("Configuration Service", test_configuration_service)
-    ]
-
-    results = []
-
-    for test_name, test_func in tests:
-        try:
-            result = test_func()
-            results.append((test_name, result))
-        except Exception as e:
-            print(f"\n✗ {test_name} failed with exception: {e}")
-            results.append((test_name, False))
-
-    # Print summary
-    print("\n" + "=" * 60)
-    print("Test Results Summary")
-    print("=" * 60)
-
-    passed = 0
-    failed = 0
-
-    for test_name, result in results:
-        status = "✓ PASSED" if result else "✗ FAILED"
-        print(f"{test_name:<30} {status}")
-
-        if result:
-            passed += 1
-        else:
-            failed += 1
-
-    print(f"\nTotal: {len(results)} tests, {passed} passed, {failed} failed")
-
-    if failed == 0:
-        print("\n🎉 All tests passed!")
-        return 0
-    else:
-        print(f"\n❌ {failed} test(s) failed!")
-        return 1
-
-
-if __name__ == "__main__":
-    sys.exit(main())

test_dtos.py

@@ -1,182 +0,0 @@
-#!/usr/bin/env python3
-"""Test script for DTOs"""
-
-import sys
-import os
-sys.path.insert(0, os.path.join(os.path.dirname(__file__), 'src'))
-
-from application.dtos import AudioUploadDto, ProcessingRequestDto, ProcessingResultDto, ValidationError
-
-def test_audio_upload_dto():
-    """Test AudioUploadDto"""
-    print("Testing AudioUploadDto...")
-    
-    # Test valid DTO
-    try:
-        audio_dto = AudioUploadDto(
-            filename="test.wav",
-            content=b"fake audio content" * 100,  # Make it larger than 1KB
-            content_type="audio/wav"
-        )
-        print(f"✓ Valid AudioUploadDto created: {audio_dto.filename}")
-        print(f"  Size: {audio_dto.size} bytes")
-        print(f"  Extension: {audio_dto.file_extension}")
-        print(f"  Base filename: {audio_dto.base_filename}")
-    except Exception as e:
-        print(f"✗ Failed to create valid AudioUploadDto: {e}")
-    
-    # Test invalid extension
-    try:
-        AudioUploadDto(
-            filename="test.txt",
-            content=b"fake content" * 100,
-            content_type="text/plain"
-        )
-        print("✗ Should have failed with invalid extension")
-    except ValueError as e:
-        print(f"✓ Correctly rejected invalid extension: {e}")
-    
-    # Test empty content
-    try:
-        AudioUploadDto(
-            filename="test.wav",
-            content=b"",
-            content_type="audio/wav"
-        )
-        print("✗ Should have failed with empty content")
-    except ValueError as e:
-        print(f"✓ Correctly rejected empty content: {e}")
-
-def test_processing_request_dto():
-    """Test ProcessingRequestDto"""
-    print("\nTesting ProcessingRequestDto...")
-    
-    # Create valid audio DTO first
-    audio_dto = AudioUploadDto(
-        filename="test.wav",
-        content=b"fake audio content" * 100,
-        content_type="audio/wav"
-    )
-    
-    # Test valid DTO
-    try:
-        request_dto = ProcessingRequestDto(
-            audio=audio_dto,
-            asr_model="whisper-small",
-            target_language="es",
-            voice="kokoro",
-            speed=1.2,
-            source_language="en"
-        )
-        print(f"✓ Valid ProcessingRequestDto created")
-        print(f"  ASR Model: {request_dto.asr_model}")
-        print(f"  Target Language: {request_dto.target_language}")
-        print(f"  Requires Translation: {request_dto.requires_translation}")
-        print(f"  Dict representation keys: {list(request_dto.to_dict().keys())}")
-    except Exception as e:
-        print(f"✗ Failed to create valid ProcessingRequestDto: {e}")
-    
-    # Test invalid speed
-    try:
-        ProcessingRequestDto(
-            audio=audio_dto,
-            asr_model="whisper-small",
-            target_language="es",
-            voice="kokoro",
-            speed=3.0  # Invalid speed
-        )
-        print("✗ Should have failed with invalid speed")
-    except ValueError as e:
-        print(f"✓ Correctly rejected invalid speed: {e}")
-    
-    # Test invalid ASR model
-    try:
-        ProcessingRequestDto(
-            audio=audio_dto,
-            asr_model="invalid-model",
-            target_language="es",
-            voice="kokoro"
-        )
-        print("✗ Should have failed with invalid ASR model")
-    except ValueError as e:
-        print(f"✓ Correctly rejected invalid ASR model: {e}")
-
-def test_processing_result_dto():
-    """Test ProcessingResultDto"""
-    print("\nTesting ProcessingResultDto...")
-    
-    # Test successful result
-    try:
-        success_result = ProcessingResultDto.success_result(
-            original_text="Hello world",
-            translated_text="Hola mundo",
-            audio_path="/tmp/output.wav",
-            processing_time=2.5
-        )
-        print(f"✓ Valid success result created")
-        print(f"  Success: {success_result.success}")
-        print(f"  Has text output: {success_result.has_text_output}")
-        print(f"  Has audio output: {success_result.has_audio_output}")
-        print(f"  Is complete: {success_result.is_complete}")
-    except Exception as e:
-        print(f"✗ Failed to create success result: {e}")
-    
-    # Test error result
-    try:
-        error_result = ProcessingResultDto.error_result(
-            error_message="TTS generation failed",
-            error_code="TTS_ERROR",
-            processing_time=1.0
-        )
-        print(f"✓ Valid error result created")
-        print(f"  Success: {error_result.success}")
-        print(f"  Error message: {error_result.error_message}")
-        print(f"  Error code: {error_result.error_code}")
-    except Exception as e:
-        print(f"✗ Failed to create error result: {e}")
-    
-    # Test invalid success result (no outputs)
-    try:
-        ProcessingResultDto(success=True)  # No outputs provided
-        print("✗ Should have failed with no outputs for success")
-    except ValueError as e:
-        print(f"✓ Correctly rejected success result with no outputs: {e}")
-    
-    # Test invalid error result (no error message)
-    try:
-        ProcessingResultDto(success=False)  # No error message
-        print("✗ Should have failed with no error message for failure")
-    except ValueError as e:
-        print(f"✓ Correctly rejected error result with no message: {e}")
-
-def test_dto_serialization():
-    """Test DTO serialization/deserialization"""
-    print("\nTesting DTO serialization...")
-    
-    # Test ProcessingResultDto serialization
-    try:
-        original_result = ProcessingResultDto.success_result(
-            original_text="Test text",
-            translated_text="Texto de prueba",
-            audio_path="/tmp/test.wav",
-            processing_time=1.5
-        )
-        
-        # Convert to dict and back
-        result_dict = original_result.to_dict()
-        restored_result = ProcessingResultDto.from_dict(result_dict)
-        
-        print(f"✓ ProcessingResultDto serialization successful")
-        print(f"  Original success: {original_result.success}")
-        print(f"  Restored success: {restored_result.success}")
-        print(f"  Original text matches: {original_result.original_text == restored_result.original_text}")
-        
-    except Exception as e:
-        print(f"✗ ProcessingResultDto serialization failed: {e}")
-
-if __name__ == "__main__":
-    test_audio_upload_dto()
-    test_processing_request_dto()
-    test_processing_result_dto()
-    test_dto_serialization()
-    print("\nDTO testing completed!")

test_stt_migration.py

@@ -1,121 +0,0 @@
-#!/usr/bin/env python3
-"""Test script for STT migration."""
-
-import sys
-import logging
-from pathlib import Path
-
-# Add src to path
-sys.path.insert(0, str(Path(__file__).parent / "src"))
-
-# Configure logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-def test_provider_availability():
-    """Test that providers can be imported and checked for availability."""
-    try:
-        from infrastructure.stt import STTProviderFactory, WhisperSTTProvider, ParakeetSTTProvider
-        
-        print("✓ Successfully imported STT providers")
-        
-        # Test factory
-        available_providers = STTProviderFactory.get_available_providers()
-        print(f"Available providers: {available_providers}")
-        
-        # Test individual providers
-        whisper = WhisperSTTProvider()
-        print(f"Whisper available: {whisper.is_available()}")
-        print(f"Whisper models: {whisper.get_available_models()}")
-        print(f"Whisper default model: {whisper.get_default_model()}")
-        
-        parakeet = ParakeetSTTProvider()
-        print(f"Parakeet available: {parakeet.is_available()}")
-        print(f"Parakeet models: {parakeet.get_available_models()}")
-        print(f"Parakeet default model: {parakeet.get_default_model()}")
-        
-        return True
-        
-    except Exception as e:
-        print(f"✗ Error testing providers: {e}")
-        import traceback
-        traceback.print_exc()
-        return False
-
-def test_legacy_compatibility():
-    """Test legacy compatibility functions."""
-    try:
-        from infrastructure.stt import transcribe_audio, ASRFactory
-        
-        print("✓ Successfully imported legacy compatibility functions")
-        
-        # Test ASRFactory
-        try:
-            model = ASRFactory.get_model("whisper")
-            print(f"✓ ASRFactory created model: {model.provider_name}")
-        except Exception as e:
-            print(f"ASRFactory test failed (expected if dependencies missing): {e}")
-        
-        return True
-        
-    except Exception as e:
-        print(f"✗ Error testing legacy compatibility: {e}")
-        import traceback
-        traceback.print_exc()
-        return False
-
-def test_domain_integration():
-    """Test integration with domain models."""
-    try:
-        from domain.models.audio_content import AudioContent
-        from domain.models.text_content import TextContent
-        from domain.exceptions import SpeechRecognitionException
-        
-        print("✓ Successfully imported domain models")
-        
-        # Create test audio content
-        test_audio = AudioContent(
-            data=b"fake audio data for testing",
-            format="wav",
-            sample_rate=16000,
-            duration=1.0,
-            filename="test.wav"
-        )
-        
-        print(f"✓ Created test AudioContent: {test_audio.filename}")
-        
-        return True
-        
-    except Exception as e:
-        print(f"✗ Error testing domain integration: {e}")
-        import traceback
-        traceback.print_exc()
-        return False
-
-if __name__ == "__main__":
-    print("Testing STT migration...")
-    print("=" * 50)
-    
-    tests = [
-        ("Provider Availability", test_provider_availability),
-        ("Legacy Compatibility", test_legacy_compatibility),
-        ("Domain Integration", test_domain_integration)
-    ]
-    
-    results = []
-    for test_name, test_func in tests:
-        print(f"\n{test_name}:")
-        print("-" * 30)
-        result = test_func()
-        results.append((test_name, result))
-    
-    print("\n" + "=" * 50)
-    print("Test Results:")
-    for test_name, result in results:
-        status = "✓ PASS" if result else "✗ FAIL"
-        print(f"{test_name}: {status}")
-    
-    all_passed = all(result for _, result in results)
-    print(f"\nOverall: {'✓ ALL TESTS PASSED' if all_passed else '✗ SOME TESTS FAILED'}")
-    
-    sys.exit(0 if all_passed else 1)

test_translation_migration.py

@@ -1,156 +0,0 @@
-#!/usr/bin/env python3
-"""Test script to verify the translation service migration."""
-
-import sys
-import os
-
-# Add src to path
-sys.path.insert(0, os.path.join(os.path.dirname(__file__), 'src'))
-
-def test_translation_provider_creation():
-    """Test that we can create translation providers."""
-    print("Testing translation provider creation...")
-    
-    try:
-        from infrastructure.translation.provider_factory import (
-            TranslationProviderFactory, 
-            TranslationProviderType
-        )
-        
-        factory = TranslationProviderFactory()
-        
-        # Test getting available providers
-        available = factory.get_available_providers()
-        print(f"Available providers: {[p.value for p in available]}")
-        
-        # Test provider info
-        all_info = factory.get_all_providers_info()
-        print(f"Provider info: {all_info}")
-        
-        # Test creating NLLB provider (may fail if transformers not installed)
-        try:
-            provider = factory.create_provider(TranslationProviderType.NLLB)
-            print(f"Created provider: {provider.provider_name}")
-            print(f"Provider available: {provider.is_available()}")
-            
-            # Test supported languages
-            supported = provider.get_supported_languages()
-            print(f"Supported language pairs: {len(supported)} source languages")
-            
-            if 'en' in supported:
-                print(f"English can translate to: {len(supported['en'])} languages")
-            
-        except Exception as e:
-            print(f"Could not create NLLB provider (expected if transformers not installed): {e}")
-        
-        print("✓ Translation provider creation test passed")
-        return True
-        
-    except Exception as e:
-        print(f"✗ Translation provider creation test failed: {e}")
-        return False
-
-def test_domain_models():
-    """Test that domain models work correctly."""
-    print("\nTesting domain models...")
-    
-    try:
-        from domain.models.text_content import TextContent
-        from domain.models.translation_request import TranslationRequest
-        
-        # Test TextContent creation
-        text_content = TextContent(
-            text="Hello, world!",
-            language="en",
-            encoding="utf-8"
-        )
-        print(f"Created TextContent: {text_content.text} ({text_content.language})")
-        
-        # Test TranslationRequest creation
-        translation_request = TranslationRequest(
-            source_text=text_content,
-            target_language="zh"
-        )
-        print(f"Created TranslationRequest: {translation_request.effective_source_language} -> {translation_request.target_language}")
-        
-        print("✓ Domain models test passed")
-        return True
-        
-    except Exception as e:
-        print(f"✗ Domain models test failed: {e}")
-        return False
-
-def test_base_class_functionality():
-    """Test the base class functionality."""
-    print("\nTesting base class functionality...")
-    
-    try:
-        from infrastructure.base.translation_provider_base import TranslationProviderBase
-        from domain.models.text_content import TextContent
-        from domain.models.translation_request import TranslationRequest
-        
-        # Create a mock provider for testing
-        class MockTranslationProvider(TranslationProviderBase):
-            def __init__(self):
-                super().__init__("MockProvider", {"en": ["zh", "es", "fr"]})
-            
-            def _translate_chunk(self, text: str, source_language: str, target_language: str) -> str:
-                return f"[TRANSLATED:{source_language}->{target_language}]{text}"
-            
-            def is_available(self) -> bool:
-                return True
-            
-            def get_supported_languages(self) -> dict:
-                return self.supported_languages
-        
-        # Test the mock provider
-        provider = MockTranslationProvider()
-        
-        # Test text chunking
-        long_text = "This is a test sentence. " * 50  # Create long text
-        chunks = provider._chunk_text(long_text)
-        print(f"Text chunked into {len(chunks)} pieces")
-        
-        # Test translation request
-        text_content = TextContent(text="Hello world", language="en")
-        request = TranslationRequest(source_text=text_content, target_language="zh")
-        
-        result = provider.translate(request)
-        print(f"Translation result: {result.text}")
-        
-        print("✓ Base class functionality test passed")
-        return True
-        
-    except Exception as e:
-        print(f"✗ Base class functionality test failed: {e}")
-        return False
-
-def main():
-    """Run all tests."""
-    print("Running translation service migration tests...\n")
-    
-    tests = [
-        test_domain_models,
-        test_translation_provider_creation,
-        test_base_class_functionality
-    ]
-    
-    passed = 0
-    total = len(tests)
-    
-    for test in tests:
-        if test():
-            passed += 1
-    
-    print(f"\n{'='*50}")
-    print(f"Test Results: {passed}/{total} tests passed")
-    
-    if passed == total:
-        print("🎉 All tests passed! Translation service migration is working correctly.")
-        return 0
-    else:
-        print("❌ Some tests failed. Please check the implementation.")
-        return 1
-
-if __name__ == "__main__":
-    sys.exit(main())

test_tts_migration.py

@@ -1,137 +0,0 @@
-#!/usr/bin/env python3
-"""Test script to verify TTS provider migration."""
-
-import sys
-import os
-
-# Add src to path
-sys.path.insert(0, os.path.join(os.path.dirname(__file__), 'src'))
-
-def test_provider_imports():
-    """Test that all providers can be imported."""
-    print("Testing provider imports...")
-    
-    try:
-        from src.infrastructure.tts import TTSProviderFactory, DummyTTSProvider
-        print("✓ Core TTS components imported successfully")
-    except Exception as e:
-        print(f"✗ Failed to import core TTS components: {e}")
-        return False
-    
-    try:
-        from src.domain.models.text_content import TextContent
-        from src.domain.models.voice_settings import VoiceSettings
-        from src.domain.models.speech_synthesis_request import SpeechSynthesisRequest
-        print("✓ Domain models imported successfully")
-    except Exception as e:
-        print(f"✗ Failed to import domain models: {e}")
-        return False
-    
-    return True
-
-def test_dummy_provider():
-    """Test the dummy provider functionality."""
-    print("\nTesting dummy provider...")
-    
-    try:
-        from src.infrastructure.tts import DummyTTSProvider
-        from src.domain.models.text_content import TextContent
-        from src.domain.models.voice_settings import VoiceSettings
-        from src.domain.models.speech_synthesis_request import SpeechSynthesisRequest
-        
-        # Create provider
-        provider = DummyTTSProvider()
-        print(f"✓ Created dummy provider: {provider.provider_name}")
-        
-        # Check availability
-        if provider.is_available():
-            print("✓ Dummy provider is available")
-        else:
-            print("✗ Dummy provider is not available")
-            return False
-        
-        # Check voices
-        voices = provider.get_available_voices()
-        print(f"✓ Available voices: {voices}")
-        
-        # Create a synthesis request
-        text_content = TextContent(text="Hello, world!", language="en")
-        voice_settings = VoiceSettings(voice_id="default", speed=1.0, language="en")
-        request = SpeechSynthesisRequest(
-            text_content=text_content,
-            voice_settings=voice_settings
-        )
-        print("✓ Created synthesis request")
-        
-        # Test synthesis
-        audio_content = provider.synthesize(request)
-        print(f"✓ Generated audio: {len(audio_content.data)} bytes, {audio_content.duration:.2f}s")
-        
-        return True
-        
-    except Exception as e:
-        print(f"✗ Dummy provider test failed: {e}")
-        import traceback
-        traceback.print_exc()
-        return False
-
-def test_provider_factory():
-    """Test the provider factory."""
-    print("\nTesting provider factory...")
-    
-    try:
-        from src.infrastructure.tts import TTSProviderFactory
-        
-        factory = TTSProviderFactory()
-        print("✓ Created provider factory")
-        
-        available = factory.get_available_providers()
-        print(f"✓ Available providers: {available}")
-        
-        if 'dummy' not in available:
-            print("✗ Dummy provider should always be available")
-            return False
-        
-        # Test creating dummy provider
-        provider = factory.create_provider('dummy')
-        print(f"✓ Created provider via factory: {provider.provider_name}")
-        
-        # Test fallback logic
-        provider = factory.get_provider_with_fallback()
-        print(f"✓ Got provider with fallback: {provider.provider_name}")
-        
-        return True
-        
-    except Exception as e:
-        print(f"✗ Provider factory test failed: {e}")
-        import traceback
-        traceback.print_exc()
-        return False
-
-def main():
-    """Run all tests."""
-    print("=== TTS Provider Migration Test ===\n")
-    
-    tests = [
-        test_provider_imports,
-        test_dummy_provider,
-        test_provider_factory
-    ]
-    
-    passed = 0
-    for test in tests:
-        if test():
-            passed += 1
-        print()
-    
-    print(f"=== Results: {passed}/{len(tests)} tests passed ===")
-    
-    if passed == len(tests):
-        print("🎉 All tests passed! TTS provider migration successful.")
-        return 0
-    else:
-        print("❌ Some tests failed. Check the output above.")
-        return 1
-
-if __name__ == "__main__":
-    sys.exit(main())