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

backend/tests/test_style_upload.py

@@ -0,0 +1,261 @@
+"""
+Tests for style file upload and processing.
+
+Tests the full flow:
+1. CLI parses style_params.json and extracts file references
+2. Upload endpoint accepts style files
+3. Style helper downloads and parses style config
+4. Workers use style config for video generation
+"""
+import pytest
+import json
+import tempfile
+import os
+from pathlib import Path
+from unittest.mock import Mock, MagicMock, patch, AsyncMock
+from io import BytesIO
+
+# Test the remote CLI's style parsing
+# Skip this class if flacfetch is not properly installed (remote_cli depends on it)
+try:
+    from karaoke_gen.utils.remote_cli import RemoteKaraokeClient, Config
+    _remote_cli_available = True
+except ImportError:
+    _remote_cli_available = False
+
+
+@pytest.mark.skipif(not _remote_cli_available, reason="flacfetch not properly installed")
+class TestRemoteCLIStyleParsing:
+    """Test that remote CLI correctly parses style_params.json."""
+    
+    def test_parse_style_params_extracts_file_paths(self):
+        """Test that _parse_style_params extracts all file references."""
+        
+        # Create a mock style_params.json
+        with tempfile.TemporaryDirectory() as temp_dir:
+            # Create test files
+            font_path = os.path.join(temp_dir, "font.ttf")
+            intro_bg_path = os.path.join(temp_dir, "intro_bg.png")
+            karaoke_bg_path = os.path.join(temp_dir, "karaoke_bg.png")
+            
+            Path(font_path).touch()
+            Path(intro_bg_path).touch()
+            Path(karaoke_bg_path).touch()
+            
+            # Create style_params.json
+            style_params = {
+                "intro": {
+                    "background_image": intro_bg_path,
+                    "font": font_path,
+                },
+                "karaoke": {
+                    "background_image": karaoke_bg_path,
+                    "font_path": font_path,
+                },
+                "end": {
+                    "background_image": karaoke_bg_path,
+                    "font": font_path,
+                },
+                "cdg": {
+                    "font_path": font_path,
+                }
+            }
+            
+            style_json_path = os.path.join(temp_dir, "style_params.json")
+            with open(style_json_path, 'w') as f:
+                json.dump(style_params, f)
+            
+            # Create client and parse
+            config = Config(
+                service_url="http://test", 
+                review_ui_url="http://test",
+                poll_interval=5,
+                output_dir=temp_dir
+            )
+            logger = Mock()
+            client = RemoteKaraokeClient(config, logger)
+            
+            assets = client._parse_style_params(style_json_path)
+            
+            # Should extract unique files
+            assert 'style_font' in assets
+            assert 'style_intro_background' in assets
+            assert 'style_karaoke_background' in assets
+            assert assets['style_font'] == font_path
+            assert assets['style_intro_background'] == intro_bg_path
+            assert assets['style_karaoke_background'] == karaoke_bg_path
+    
+    def test_parse_style_params_handles_missing_files(self):
+        """Test that _parse_style_params ignores non-existent files."""
+        
+        with tempfile.TemporaryDirectory() as temp_dir:
+            style_params = {
+                "intro": {
+                    "background_image": "/nonexistent/path.png",
+                    "font": "/nonexistent/font.ttf",
+                },
+            }
+            
+            style_json_path = os.path.join(temp_dir, "style_params.json")
+            with open(style_json_path, 'w') as f:
+                json.dump(style_params, f)
+            
+            config = Config(
+                service_url="http://test", 
+                review_ui_url="http://test",
+                poll_interval=5,
+                output_dir=temp_dir
+            )
+            logger = Mock()
+            client = RemoteKaraokeClient(config, logger)
+            
+            assets = client._parse_style_params(style_json_path)
+            
+            # Should return empty dict for non-existent files
+            assert len(assets) == 0
+
+
+class TestStyleHelper:
+    """Test the backend style helper module."""
+    
+    @pytest.mark.asyncio
+    async def test_style_config_loads_defaults_when_no_custom_styles(self):
+        """Test that StyleConfig returns defaults when no custom styles."""
+        pytest.importorskip("google.cloud.storage", reason="GCP libraries not available")
+        from backend.workers.style_helper import StyleConfig, DEFAULT_INTRO_FORMAT
+        
+        # Mock job with no style assets and no style_params_gcs_path
+        job = Mock()
+        job.job_id = "test-123"
+        job.style_assets = {}
+        job.style_params_gcs_path = None  # Explicitly set to None
+        
+        storage = Mock()
+        
+        with tempfile.TemporaryDirectory() as temp_dir:
+            config = StyleConfig(job, storage, temp_dir)
+            await config.load()
+            
+            assert not config.has_custom_styles()
+            intro_format = config.get_intro_format()
+            assert intro_format == DEFAULT_INTRO_FORMAT
+    
+    @pytest.mark.asyncio
+    async def test_style_config_loads_custom_styles(self):
+        """Test that StyleConfig loads and parses custom styles."""
+        pytest.importorskip("google.cloud.storage", reason="GCP libraries not available")
+        from backend.workers.style_helper import StyleConfig
+        
+        with tempfile.TemporaryDirectory() as temp_dir:
+            # Create a SEPARATE source directory for the source style file
+            # (StyleConfig will use temp_dir/style/ for downloads, so we use source/)
+            source_dir = os.path.join(temp_dir, "source")
+            os.makedirs(source_dir, exist_ok=True)
+            
+            # Create a mock style_params.json in the source directory
+            style_params = {
+                "intro": {
+                    "background_color": "#FF0000",
+                    "title_color": "#00FF00",
+                },
+                "cdg": {
+                    "background_color": "#0000FF",
+                }
+            }
+            style_json_path = os.path.join(source_dir, "style_params.json")
+            with open(style_json_path, 'w') as f:
+                json.dump(style_params, f)
+            
+            # Create a work directory for StyleConfig (separate from source)
+            work_dir = os.path.join(temp_dir, "work")
+            os.makedirs(work_dir, exist_ok=True)
+            
+            # Mock job with style assets
+            job = Mock()
+            job.job_id = "test-123"
+            job.style_assets = {"style_params": "uploads/test/style_params.json"}
+            
+            # Mock storage to "download" the file
+            storage = Mock()
+            def mock_download(gcs_path, local_path):
+                # Copy our test file to the expected location
+                import shutil
+                os.makedirs(os.path.dirname(local_path), exist_ok=True)
+                shutil.copy(style_json_path, local_path)
+            storage.download_file = mock_download
+            
+            config = StyleConfig(job, storage, work_dir)
+            await config.load()
+            
+            assert config.has_custom_styles()
+            
+            intro_format = config.get_intro_format()
+            assert intro_format['background_color'] == "#FF0000"
+            assert intro_format['title_color'] == "#00FF00"
+            
+            cdg_styles = config.get_cdg_styles()
+            assert cdg_styles['background_color'] == "#0000FF"
+
+
+class TestFileUploadEndpoint:
+    """Test the file upload endpoint accepts style files."""
+    
+    def test_upload_endpoint_validates_style_files(self):
+        """Test that upload endpoint validates file types."""
+        pytest.importorskip("google.cloud.firestore", reason="GCP libraries not available")
+        # This would be an integration test with FastAPI TestClient
+        # For now, just verify the validation logic exists
+        from backend.api.routes.file_upload import (
+            ALLOWED_AUDIO_EXTENSIONS,
+            ALLOWED_IMAGE_EXTENSIONS,
+            ALLOWED_FONT_EXTENSIONS
+        )
+        
+        assert '.mp3' in ALLOWED_AUDIO_EXTENSIONS
+        assert '.flac' in ALLOWED_AUDIO_EXTENSIONS
+        assert '.png' in ALLOWED_IMAGE_EXTENSIONS
+        assert '.jpg' in ALLOWED_IMAGE_EXTENSIONS
+        assert '.ttf' in ALLOWED_FONT_EXTENSIONS
+        assert '.otf' in ALLOWED_FONT_EXTENSIONS
+
+
+class TestVideoWorkerStyleIntegration:
+    """Test that video worker properly uses style config."""
+    
+    def test_video_worker_passes_cdg_styles_to_finalise(self):
+        """Test that video worker passes CDG styles to KaraokeFinalise."""
+        pytest.importorskip("google.cloud.firestore", reason="GCP libraries not available")
+        # This is implicitly tested by the video_worker code structure
+        # The key is that cdg_styles is passed to KaraokeFinalise constructor
+        
+        # Verify the import works
+        from backend.workers.video_worker import generate_video
+        assert generate_video is not None
+    
+    def test_video_worker_passes_discord_webhook(self):
+        """Test that video worker passes discord webhook to KaraokeFinalise."""
+        # The video_worker.py now passes discord_webhook_url from job
+        # This is verified by code inspection
+        pass
+
+
+class TestJobModelStyleFields:
+    """Test that Job model has all required style fields."""
+    
+    def test_job_model_has_style_fields(self):
+        """Test Job model includes style configuration fields."""
+        from backend.models.job import Job, JobCreate
+        
+        # Check Job model fields (use model_fields for Pydantic v2)
+        job_fields = Job.model_fields if hasattr(Job, 'model_fields') else Job.__fields__
+        assert 'style_params_gcs_path' in job_fields
+        assert 'style_assets' in job_fields
+        assert 'brand_prefix' in job_fields
+        assert 'discord_webhook_url' in job_fields
+        
+        # Check JobCreate model fields
+        create_fields = JobCreate.model_fields if hasattr(JobCreate, 'model_fields') else JobCreate.__fields__
+        assert 'style_params_gcs_path' in create_fields
+        assert 'style_assets' in create_fields
+        assert 'brand_prefix' in create_fields
+        assert 'discord_webhook_url' in create_fields

backend/tests/test_template_service.py

@@ -0,0 +1,295 @@
+"""
+Unit tests for template service.
+"""
+import pytest
+from unittest.mock import Mock, patch, MagicMock
+
+from backend.services.template_service import (
+    TemplateService,
+    get_template_service,
+    DEFAULT_JOB_COMPLETION_TEMPLATE,
+    DEFAULT_ACTION_NEEDED_LYRICS_TEMPLATE,
+    DEFAULT_ACTION_NEEDED_INSTRUMENTAL_TEMPLATE,
+)
+
+
+class TestTemplateRendering:
+    """Tests for template rendering functionality."""
+
+    def test_render_template_basic(self):
+        """Test basic template variable replacement."""
+        service = TemplateService()
+        template = "Hello {name}, your job {job_id} is ready!"
+        variables = {"name": "Alice", "job_id": "123"}
+
+        result = service.render_template(template, variables)
+
+        assert result == "Hello Alice, your job 123 is ready!"
+
+    def test_render_template_missing_variables(self):
+        """Test that missing variables are replaced with empty strings."""
+        service = TemplateService()
+        template = "Hello {name}, your {thing} is {status}!"
+        variables = {"name": "Bob"}
+
+        result = service.render_template(template, variables)
+
+        assert result == "Hello Bob, your  is !"
+
+    def test_render_template_none_values(self):
+        """Test that None values are handled correctly."""
+        service = TemplateService()
+        template = "Hello {name}!"
+        variables = {"name": None}
+
+        result = service.render_template(template, variables)
+
+        assert result == "Hello !"
+
+    def test_render_template_removes_feedback_section_when_no_url(self):
+        """Test that feedback section is removed when feedback_url is not provided."""
+        service = TemplateService()
+        template = """Thanks for your order!
+
+If you have a moment, I'd really appreciate your feedback (takes 2 minutes):
+{feedback_url}
+
+Have a great day!"""
+        variables = {"feedback_url": None}
+
+        result = service.render_template(template, variables)
+
+        assert "feedback" not in result.lower()
+        assert "Thanks for your order!" in result
+        assert "Have a great day!" in result
+
+    def test_render_template_keeps_feedback_section_when_url_provided(self):
+        """Test that feedback section is kept when feedback_url is provided."""
+        service = TemplateService()
+        template = """Thanks!
+
+If you have a moment, I'd really appreciate your feedback (takes 2 minutes):
+{feedback_url}
+
+Bye!"""
+        variables = {"feedback_url": "https://example.com/feedback"}
+
+        result = service.render_template(template, variables)
+
+        assert "https://example.com/feedback" in result
+        assert "feedback" in result.lower()
+
+
+class TestJobCompletionTemplate:
+    """Tests for job completion template rendering."""
+
+    def test_render_job_completion_all_fields(self):
+        """Test rendering job completion with all fields."""
+        service = TemplateService()
+
+        # Mock _fetch_template_from_gcs to return None (use default)
+        with patch.object(service, "_fetch_template_from_gcs", return_value=None):
+            result = service.render_job_completion(
+                name="Alice",
+                youtube_url="https://youtube.com/watch?v=123",
+                dropbox_url="https://dropbox.com/folder/abc",
+                artist="Test Artist",
+                title="Test Song",
+                job_id="job-123",
+                feedback_url="https://example.com/feedback",
+            )
+
+        assert "Alice" in result
+        assert "https://youtube.com/watch?v=123" in result
+        assert "https://dropbox.com/folder/abc" in result
+        assert "https://example.com/feedback" in result
+
+    def test_render_job_completion_defaults(self):
+        """Test rendering job completion with default values."""
+        service = TemplateService()
+
+        with patch.object(service, "_fetch_template_from_gcs", return_value=None):
+            result = service.render_job_completion()
+
+        assert "there" in result  # Default name
+        assert "[YouTube URL not available]" in result
+        assert "[Dropbox URL not available]" in result
+
+    def test_render_job_completion_no_feedback_url(self):
+        """Test rendering job completion without feedback URL removes section."""
+        service = TemplateService()
+
+        with patch.object(service, "_fetch_template_from_gcs", return_value=None):
+            result = service.render_job_completion(
+                name="Bob",
+                youtube_url="https://youtube.com/123",
+                dropbox_url="https://dropbox.com/abc",
+            )
+
+        assert "Bob" in result
+        # Feedback section should be removed
+        assert "really appreciate your feedback" not in result
+
+
+class TestActionNeededTemplates:
+    """Tests for action-needed template rendering."""
+
+    def test_render_action_needed_lyrics(self):
+        """Test rendering lyrics review reminder."""
+        service = TemplateService()
+
+        with patch.object(service, "_fetch_template_from_gcs", return_value=None):
+            result = service.render_action_needed_lyrics(
+                name="Charlie",
+                artist="Test Artist",
+                title="Test Song",
+                review_url="https://example.com/review",
+            )
+
+        assert "Charlie" in result
+        assert "Test Artist" in result
+        assert "Test Song" in result
+        assert "https://example.com/review" in result
+
+    def test_render_action_needed_instrumental(self):
+        """Test rendering instrumental selection reminder."""
+        service = TemplateService()
+
+        with patch.object(service, "_fetch_template_from_gcs", return_value=None):
+            result = service.render_action_needed_instrumental(
+                name="Diana",
+                artist="Test Artist",
+                title="Test Song",
+                instrumental_url="https://example.com/instrumental",
+            )
+
+        assert "Diana" in result
+        assert "Test Artist" in result
+        assert "Test Song" in result
+        assert "https://example.com/instrumental" in result
+
+
+class TestGCSFetching:
+    """Tests for GCS template fetching."""
+
+    def test_fetch_template_from_gcs_success(self):
+        """Test successful template fetch from GCS."""
+        service = TemplateService()
+
+        # Mock the bucket and blob
+        mock_blob = Mock()
+        mock_blob.exists.return_value = True
+        mock_blob.download_as_text.return_value = "Custom template {name}"
+
+        mock_bucket = Mock()
+        mock_bucket.blob.return_value = mock_blob
+
+        with patch.object(service, "_bucket", mock_bucket):
+            result = service._fetch_template_from_gcs("test.txt")
+
+        assert result == "Custom template {name}"
+        mock_bucket.blob.assert_called_once_with("templates/test.txt")
+
+    def test_fetch_template_from_gcs_not_found(self):
+        """Test template fetch when file doesn't exist in GCS."""
+        service = TemplateService()
+
+        mock_blob = Mock()
+        mock_blob.exists.return_value = False
+
+        mock_bucket = Mock()
+        mock_bucket.blob.return_value = mock_blob
+
+        with patch.object(service, "_bucket", mock_bucket):
+            result = service._fetch_template_from_gcs("nonexistent.txt")
+
+        assert result is None
+
+    def test_fetch_template_from_gcs_error(self):
+        """Test template fetch handles errors gracefully."""
+        service = TemplateService()
+
+        mock_bucket = Mock()
+        mock_bucket.blob.side_effect = Exception("GCS error")
+
+        with patch.object(service, "_bucket", mock_bucket):
+            result = service._fetch_template_from_gcs("test.txt")
+
+        assert result is None
+
+    def test_get_job_completion_template_fallback(self):
+        """Test that default template is used when GCS fetch fails."""
+        service = TemplateService()
+
+        with patch.object(service, "_fetch_template_from_gcs", return_value=None):
+            result = service.get_job_completion_template()
+
+        assert result == DEFAULT_JOB_COMPLETION_TEMPLATE
+
+    def test_get_action_needed_lyrics_template_fallback(self):
+        """Test that default lyrics template is used when GCS fetch fails."""
+        service = TemplateService()
+
+        with patch.object(service, "_fetch_template_from_gcs", return_value=None):
+            result = service.get_action_needed_lyrics_template()
+
+        assert result == DEFAULT_ACTION_NEEDED_LYRICS_TEMPLATE
+
+    def test_get_action_needed_instrumental_template_fallback(self):
+        """Test that default instrumental template is used when GCS fetch fails."""
+        service = TemplateService()
+
+        with patch.object(service, "_fetch_template_from_gcs", return_value=None):
+            result = service.get_action_needed_instrumental_template()
+
+        assert result == DEFAULT_ACTION_NEEDED_INSTRUMENTAL_TEMPLATE
+
+
+class TestTemplateUpload:
+    """Tests for template upload functionality."""
+
+    def test_upload_template_success(self):
+        """Test successful template upload."""
+        service = TemplateService()
+
+        mock_blob = Mock()
+        mock_bucket = Mock()
+        mock_bucket.blob.return_value = mock_blob
+
+        with patch.object(service, "_bucket", mock_bucket):
+            result = service.upload_template("test.txt", "Test content")
+
+        assert result is True
+        mock_bucket.blob.assert_called_once_with("templates/test.txt")
+        mock_blob.upload_from_string.assert_called_once_with(
+            "Test content", content_type="text/plain"
+        )
+
+    def test_upload_template_error(self):
+        """Test template upload handles errors."""
+        service = TemplateService()
+
+        mock_blob = Mock()
+        mock_blob.upload_from_string.side_effect = Exception("Upload failed")
+        mock_bucket = Mock()
+        mock_bucket.blob.return_value = mock_blob
+
+        with patch.object(service, "_bucket", mock_bucket):
+            result = service.upload_template("test.txt", "Test content")
+
+        assert result is False
+
+
+class TestGlobalInstance:
+    """Tests for global instance management."""
+
+    def test_get_template_service_returns_same_instance(self):
+        """Test that get_template_service returns singleton."""
+        # Reset global
+        import backend.services.template_service as ts
+        ts._template_service = None
+
+        service1 = get_template_service()
+        service2 = get_template_service()
+
+        assert service1 is service2