karaoke-gen 0.90.1__py3-none-any.whl → 0.96.0__py3-none-any.whl

backend/tests/test_workers_extended.py

@@ -0,0 +1,178 @@
+"""
+Extended worker tests focusing on helper functions and utilities.
+
+These tests increase coverage without requiring complex external mocking.
+"""
+import pytest
+import os
+import json
+import tempfile
+from datetime import datetime, UTC
+from unittest.mock import MagicMock, AsyncMock, patch
+
+from backend.models.job import Job, JobStatus
+
+
+class TestAudioWorkerHelpers:
+    """Tests for audio_worker.py helper functions and utilities."""
+    
+    def test_audio_worker_module_structure(self):
+        """Test audio worker module has expected structure."""
+        from backend.workers import audio_worker
+        assert hasattr(audio_worker, 'process_audio_separation')
+        assert hasattr(audio_worker, 'download_audio')
+        assert hasattr(audio_worker, 'upload_separation_results')
+    
+    def test_audio_worker_logger_configured(self):
+        """Test audio worker has logger configured."""
+        from backend.workers.audio_worker import logger
+        assert logger is not None
+    
+    @pytest.mark.asyncio
+    async def test_upload_separation_results_with_empty_result(self):
+        """Test upload with empty separation result."""
+        from backend.workers.audio_worker import upload_separation_results
+        
+        mock_storage = MagicMock()
+        mock_job_manager = MagicMock()
+        mock_job_manager.get_job.return_value = Job(
+            job_id="test",
+            status=JobStatus.SEPARATING_STAGE2,
+            created_at=datetime.now(UTC),
+            updated_at=datetime.now(UTC)
+        )
+        
+        # Empty result should not crash
+        await upload_separation_results(
+            "test123",
+            {"clean_instrumental": {}, "other_stems": {}, "backing_vocals": {}, "combined_instrumentals": {}},
+            mock_storage,
+            mock_job_manager
+        )
+
+
+class TestLyricsWorkerHelpers:
+    """Tests for lyrics_worker.py helper functions."""
+    
+    def test_lyrics_worker_module_structure(self):
+        """Test lyrics worker module has expected structure."""
+        from backend.workers import lyrics_worker
+        assert hasattr(lyrics_worker, 'process_lyrics_transcription')
+        assert hasattr(lyrics_worker, 'upload_lyrics_results')
+    
+    def test_lyrics_worker_logger_configured(self):
+        """Test lyrics worker has logger configured."""
+        from backend.workers.lyrics_worker import logger
+        assert logger is not None
+
+
+class TestScreensWorkerHelpers:
+    """Tests for screens_worker.py helper functions."""
+    
+    def test_screens_worker_module_structure(self):
+        """Test screens worker module has expected structure."""
+        from backend.workers import screens_worker
+        assert hasattr(screens_worker, 'generate_screens')
+    
+    def test_screens_worker_logger_configured(self):
+        """Test screens worker has logger configured."""
+        from backend.workers.screens_worker import logger
+        assert logger is not None
+
+
+class TestVideoWorkerHelpers:
+    """Tests for video_worker.py helper functions."""
+    
+    def test_video_worker_module_structure(self):
+        """Test video worker module has expected structure."""
+        from backend.workers import video_worker
+        assert hasattr(video_worker, 'generate_video')
+    
+    def test_video_worker_logger_configured(self):
+        """Test video worker has logger configured."""
+        from backend.workers.video_worker import logger
+        assert logger is not None
+
+
+class TestWorkerJobValidation:
+    """Tests for job validation in workers."""
+    
+    @pytest.fixture
+    def mock_storage(self):
+        return MagicMock()
+    
+    @pytest.fixture
+    def mock_job_manager(self):
+        manager = MagicMock()
+        manager.mark_job_failed = MagicMock()
+        return manager
+    
+    @pytest.mark.asyncio
+    async def test_audio_worker_handles_missing_job(self, mock_storage, mock_job_manager):
+        """Test audio worker handles missing job gracefully."""
+        mock_job_manager.get_job.return_value = None
+        
+        with patch('backend.workers.audio_worker.JobManager', return_value=mock_job_manager), \
+             patch('backend.workers.audio_worker.StorageService', return_value=mock_storage):
+            from backend.workers.audio_worker import process_audio_separation
+            
+            await process_audio_separation("nonexistent")
+            # Should handle gracefully, potentially marking as failed
+    
+    @pytest.mark.asyncio
+    async def test_lyrics_worker_handles_missing_job(self, mock_storage, mock_job_manager):
+        """Test lyrics worker handles missing job gracefully."""
+        mock_job_manager.get_job.return_value = None
+        
+        with patch('backend.workers.lyrics_worker.JobManager', return_value=mock_job_manager), \
+             patch('backend.workers.lyrics_worker.StorageService', return_value=mock_storage):
+            from backend.workers.lyrics_worker import process_lyrics_transcription
+            
+            await process_lyrics_transcription("nonexistent")
+
+
+class TestWorkerFileOperations:
+    """Tests for worker file operations."""
+    
+    @pytest.mark.asyncio
+    async def test_download_audio_from_gcs_path(self):
+        """Test downloading audio from GCS path."""
+        from backend.workers.audio_worker import download_audio
+        
+        mock_storage = MagicMock()
+        mock_storage.download_file.return_value = "/tmp/test.flac"
+        
+        mock_job = Job(
+            job_id="test123",
+            status=JobStatus.DOWNLOADING,
+            created_at=datetime.now(UTC),
+            updated_at=datetime.now(UTC),
+            input_media_gcs_path="uploads/test123/song.flac"
+        )
+        
+        with tempfile.TemporaryDirectory() as temp_dir:
+            result = await download_audio("test123", temp_dir, mock_storage, mock_job)
+            mock_storage.download_file.assert_called()
+    
+    @pytest.mark.asyncio
+    async def test_lyrics_download_audio(self):
+        """Test lyrics worker downloads audio."""
+        from backend.workers.lyrics_worker import download_audio
+        
+        mock_storage = MagicMock()
+        mock_storage.download_file.return_value = "/tmp/test.flac"
+        
+        mock_job_manager = MagicMock()
+        mock_job = Job(
+            job_id="test123",
+            status=JobStatus.TRANSCRIBING,
+            created_at=datetime.now(UTC),
+            updated_at=datetime.now(UTC),
+            input_media_gcs_path="uploads/test123/song.flac"
+        )
+        mock_job_manager.get_job.return_value = mock_job
+        
+        with tempfile.TemporaryDirectory() as temp_dir:
+            result = await download_audio("test123", temp_dir, mock_storage, mock_job, mock_job_manager)
+            mock_storage.download_file.assert_called()
+

backend/tests/test_youtube_service.py

@@ -0,0 +1,247 @@
+"""
+Tests for youtube_service.py - YouTube credential management.
+
+These tests mock Secret Manager to verify:
+- Credential loading and parsing
+- Validation of required fields
+- Error handling for missing/invalid credentials
+"""
+import json
+import pytest
+from unittest.mock import Mock, patch
+
+
+class TestYouTubeServiceInit:
+    """Test YouTubeService initialization."""
+    
+    @patch("backend.services.youtube_service.get_settings")
+    def test_init_creates_service(self, mock_get_settings):
+        """Test initialization creates service with settings."""
+        from backend.services.youtube_service import YouTubeService
+        
+        mock_settings = Mock()
+        mock_get_settings.return_value = mock_settings
+        
+        service = YouTubeService()
+        
+        assert service.settings == mock_settings
+        assert service._credentials is None
+        assert service._loaded is False
+
+
+class TestLoadCredentials:
+    """Test load_credentials method."""
+    
+    @patch("backend.services.youtube_service.get_settings")
+    def test_load_credentials_success(self, mock_get_settings):
+        """Test successful credential loading from Secret Manager."""
+        from backend.services.youtube_service import YouTubeService
+        
+        mock_settings = Mock()
+        mock_settings.get_secret.return_value = json.dumps({
+            "token": "access-token-123",
+            "refresh_token": "refresh-token-456",
+            "token_uri": "https://oauth2.googleapis.com/token",
+            "client_id": "client-id.apps.googleusercontent.com",
+            "client_secret": "client-secret-789",
+            "scopes": ["https://www.googleapis.com/auth/youtube.upload"],
+        })
+        mock_get_settings.return_value = mock_settings
+        
+        service = YouTubeService()
+        result = service.load_credentials()
+        
+        assert result is True
+        assert service._credentials is not None
+        assert service._credentials["refresh_token"] == "refresh-token-456"
+        mock_settings.get_secret.assert_called_once_with("youtube-oauth-credentials")
+    
+    @patch("backend.services.youtube_service.get_settings")
+    def test_load_credentials_not_found(self, mock_get_settings):
+        """Test handling when credentials are not in Secret Manager."""
+        from backend.services.youtube_service import YouTubeService
+        
+        mock_settings = Mock()
+        mock_settings.get_secret.return_value = None
+        mock_get_settings.return_value = mock_settings
+        
+        service = YouTubeService()
+        result = service.load_credentials()
+        
+        assert result is False
+        assert service._credentials is None
+        assert service._loaded is True
+    
+    @patch("backend.services.youtube_service.get_settings")
+    def test_load_credentials_missing_required_fields(self, mock_get_settings):
+        """Test handling when credentials are missing required fields."""
+        from backend.services.youtube_service import YouTubeService
+        
+        mock_settings = Mock()
+        mock_settings.get_secret.return_value = json.dumps({
+            "token": "access-token",
+            # Missing: refresh_token, token_uri, client_id, client_secret
+        })
+        mock_get_settings.return_value = mock_settings
+        
+        service = YouTubeService()
+        result = service.load_credentials()
+        
+        assert result is False
+        assert service._credentials is None
+    
+    @patch("backend.services.youtube_service.get_settings")
+    def test_load_credentials_invalid_json(self, mock_get_settings):
+        """Test handling of invalid JSON in credentials."""
+        from backend.services.youtube_service import YouTubeService
+        
+        mock_settings = Mock()
+        mock_settings.get_secret.return_value = "not valid json {"
+        mock_get_settings.return_value = mock_settings
+        
+        service = YouTubeService()
+        result = service.load_credentials()
+        
+        assert result is False
+        assert service._credentials is None
+    
+    @patch("backend.services.youtube_service.get_settings")
+    def test_load_credentials_exception(self, mock_get_settings):
+        """Test handling of exceptions during credential loading."""
+        from backend.services.youtube_service import YouTubeService
+        
+        mock_settings = Mock()
+        mock_settings.get_secret.side_effect = Exception("Secret Manager error")
+        mock_get_settings.return_value = mock_settings
+        
+        service = YouTubeService()
+        result = service.load_credentials()
+        
+        assert result is False
+        assert service._loaded is True
+    
+    @patch("backend.services.youtube_service.get_settings")
+    def test_load_credentials_cached(self, mock_get_settings):
+        """Test that credentials are cached after first load."""
+        from backend.services.youtube_service import YouTubeService
+        
+        mock_settings = Mock()
+        mock_settings.get_secret.return_value = json.dumps({
+            "refresh_token": "token",
+            "token_uri": "uri",
+            "client_id": "id",
+            "client_secret": "secret",
+        })
+        mock_get_settings.return_value = mock_settings
+        
+        service = YouTubeService()
+        
+        # First call
+        result1 = service.load_credentials()
+        # Second call
+        result2 = service.load_credentials()
+        
+        assert result1 is True
+        assert result2 is True
+        # Secret Manager should only be called once
+        assert mock_settings.get_secret.call_count == 1
+
+
+class TestGetCredentialsDict:
+    """Test get_credentials_dict method."""
+    
+    @patch("backend.services.youtube_service.get_settings")
+    def test_get_credentials_dict_loads_if_needed(self, mock_get_settings):
+        """Test get_credentials_dict loads credentials if not already loaded."""
+        from backend.services.youtube_service import YouTubeService
+        
+        mock_settings = Mock()
+        mock_settings.get_secret.return_value = json.dumps({
+            "refresh_token": "token",
+            "token_uri": "uri",
+            "client_id": "id",
+            "client_secret": "secret",
+        })
+        mock_get_settings.return_value = mock_settings
+        
+        service = YouTubeService()
+        
+        # Don't explicitly call load_credentials
+        result = service.get_credentials_dict()
+        
+        assert result is not None
+        assert result["refresh_token"] == "token"
+    
+    @patch("backend.services.youtube_service.get_settings")
+    def test_get_credentials_dict_returns_none_if_not_configured(
+        self, mock_get_settings
+    ):
+        """Test get_credentials_dict returns None when not configured."""
+        from backend.services.youtube_service import YouTubeService
+        
+        mock_settings = Mock()
+        mock_settings.get_secret.return_value = None
+        mock_get_settings.return_value = mock_settings
+        
+        service = YouTubeService()
+        result = service.get_credentials_dict()
+        
+        assert result is None
+
+
+class TestIsConfigured:
+    """Test is_configured property."""
+    
+    @patch("backend.services.youtube_service.get_settings")
+    def test_is_configured_true(self, mock_get_settings):
+        """Test is_configured returns True when credentials exist."""
+        from backend.services.youtube_service import YouTubeService
+        
+        mock_settings = Mock()
+        mock_settings.get_secret.return_value = json.dumps({
+            "refresh_token": "token",
+            "token_uri": "uri",
+            "client_id": "id",
+            "client_secret": "secret",
+        })
+        mock_get_settings.return_value = mock_settings
+        
+        service = YouTubeService()
+        
+        assert service.is_configured is True
+    
+    @patch("backend.services.youtube_service.get_settings")
+    def test_is_configured_false(self, mock_get_settings):
+        """Test is_configured returns False when credentials missing."""
+        from backend.services.youtube_service import YouTubeService
+        
+        mock_settings = Mock()
+        mock_settings.get_secret.return_value = None
+        mock_get_settings.return_value = mock_settings
+        
+        service = YouTubeService()
+        
+        assert service.is_configured is False
+
+
+class TestGetYouTubeService:
+    """Test get_youtube_service singleton."""
+    
+    @patch("backend.services.youtube_service.get_settings")
+    def test_get_youtube_service_singleton(self, mock_get_settings):
+        """Test get_youtube_service returns singleton instance."""
+        from backend.services.youtube_service import get_youtube_service
+        import backend.services.youtube_service as youtube_module
+        
+        # Reset singleton
+        youtube_module._youtube_service = None
+        
+        mock_settings = Mock()
+        mock_settings.get_secret.return_value = None
+        mock_get_settings.return_value = mock_settings
+        
+        service1 = get_youtube_service()
+        service2 = get_youtube_service()
+        
+        assert service1 is service2
+