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

backend/tests/emulator/test_style_loading_direct.py

@@ -0,0 +1,436 @@
+"""
+Direct tests for render_video_worker style loading.
+
+Tests the fix for styles being loaded from job.style_params_gcs_path
+instead of the incorrect job.state_data['styles_gcs_path'].
+
+Run with: 
+  ./scripts/start-emulators.sh
+  pytest backend/tests/emulator/test_style_loading_direct.py -v
+"""
+import pytest
+import json
+import os
+import tempfile
+import requests
+from dataclasses import dataclass
+from typing import Dict, Optional
+
+
+def emulators_running() -> bool:
+    """Check if GCP emulators are running."""
+    try:
+        requests.get("http://127.0.0.1:8080", timeout=1)
+        requests.get("http://127.0.0.1:4443", timeout=1)
+        return True
+    except (requests.exceptions.ConnectionError, requests.exceptions.Timeout):
+        return False
+
+
+# Skip all tests in this module if emulators aren't running
+pytestmark = pytest.mark.skipif(
+    not emulators_running(),
+    reason="GCP emulators not running. Start with: scripts/start-emulators.sh"
+)
+
+# Set up environment for emulators
+os.environ["FIRESTORE_EMULATOR_HOST"] = "127.0.0.1:8080"
+os.environ["STORAGE_EMULATOR_HOST"] = "http://127.0.0.1:4443"
+os.environ["GOOGLE_CLOUD_PROJECT"] = "test-project"
+os.environ["GCS_BUCKET_NAME"] = "test-bucket"
+
+
+@dataclass
+class MockJob:
+    """Mock job object for testing style loading."""
+    job_id: str
+    style_params_gcs_path: Optional[str] = None
+    style_assets: Dict[str, str] = None
+    state_data: Dict = None
+    
+    def __post_init__(self):
+        if self.style_assets is None:
+            self.style_assets = {}
+        if self.state_data is None:
+            self.state_data = {}
+
+
+class MockStorageService:
+    """Mock storage service that uses GCS emulator."""
+    
+    def __init__(self):
+        from google.cloud import storage
+        self.client = storage.Client()
+        self.bucket_name = "test-bucket"
+        self._ensure_bucket_exists()
+    
+    def _ensure_bucket_exists(self):
+        """Create bucket in emulator if it doesn't exist."""
+        try:
+            self.client.create_bucket(self.bucket_name)
+        except Exception:
+            pass  # Bucket already exists
+    
+    def upload_string(self, content: str, gcs_path: str, content_type: str = "application/json"):
+        """Upload string content to GCS."""
+        bucket = self.client.bucket(self.bucket_name)
+        blob = bucket.blob(gcs_path)
+        blob.upload_from_string(content, content_type=content_type)
+    
+    def upload_bytes(self, content: bytes, gcs_path: str, content_type: str = "application/octet-stream"):
+        """Upload bytes to GCS."""
+        bucket = self.client.bucket(self.bucket_name)
+        blob = bucket.blob(gcs_path)
+        blob.upload_from_string(content, content_type=content_type)
+    
+    def download_file(self, gcs_path: str, local_path: str):
+        """Download file from GCS to local path."""
+        bucket = self.client.bucket(self.bucket_name)
+        blob = bucket.blob(gcs_path)
+        blob.download_to_filename(local_path)
+    
+    def file_exists(self, gcs_path: str) -> bool:
+        """Check if file exists in GCS."""
+        bucket = self.client.bucket(self.bucket_name)
+        blob = bucket.blob(gcs_path)
+        return blob.exists()
+
+
+class TestStyleLoadingFix:
+    """
+    Tests for the render_video_worker style loading fix.
+    
+    The bug was: render_video_worker looked for styles at 
+    job.state_data.get('styles_gcs_path') but styles are actually stored at
+    job.style_params_gcs_path and job.style_assets.
+    """
+    
+    @pytest.fixture(autouse=True)
+    def setup(self):
+        """Set up storage service and temp directory for each test."""
+        self.storage = MockStorageService()
+        self.temp_dir = tempfile.mkdtemp()
+        yield
+        # Cleanup
+        import shutil
+        shutil.rmtree(self.temp_dir, ignore_errors=True)
+    
+    def _import_get_or_create_styles(self):
+        """
+        Import _get_or_create_styles without importing the full worker module.
+        We copy the function here to avoid import issues with lyrics_transcriber.
+        """
+        # We'll test using a copy of the function logic
+        # This avoids importing the full worker which has lyrics_transcriber dependency
+        pass
+    
+    def test_style_loading_from_correct_location(self):
+        """
+        Test that styles are loaded from job.style_params_gcs_path,
+        NOT from job.state_data['styles_gcs_path'].
+        """
+        import time
+        job_id = f"test-style-{int(time.time() * 1000)}"
+        
+        # Create style JSON with placeholder paths
+        style_json = {
+            "intro": {
+                "background_image": "/original/path/intro_bg.png",
+                "font": "/original/path/font.ttf"
+            },
+            "karaoke": {
+                "background_image": "/original/path/karaoke_bg.png",
+                "font_path": "/original/path/font.ttf",
+                "font_size": 100
+            },
+            "end": {
+                "background_image": "/original/path/end_bg.png",
+                "font": "/original/path/font.ttf"
+            }
+        }
+        
+        # Upload style JSON to GCS (the CORRECT location)
+        style_gcs_path = f"uploads/{job_id}/style/style_params.json"
+        self.storage.upload_string(json.dumps(style_json), style_gcs_path)
+        
+        # Upload mock assets
+        assets = {
+            "intro_background": f"uploads/{job_id}/style/intro_background.png",
+            "karaoke_background": f"uploads/{job_id}/style/karaoke_background.png",
+            "end_background": f"uploads/{job_id}/style/end_background.png",
+            "font": f"uploads/{job_id}/style/font.ttf",
+        }
+        
+        for asset_key, gcs_path in assets.items():
+            # Upload fake file content
+            self.storage.upload_bytes(b"fake image/font data", gcs_path)
+        
+        # Create mock job with styles in the CORRECT location
+        job = MockJob(
+            job_id=job_id,
+            style_params_gcs_path=style_gcs_path,  # CORRECT
+            style_assets=assets,                    # CORRECT
+            state_data={}                           # state_data is EMPTY (no styles_gcs_path)
+        )
+        
+        # Verify files exist in GCS
+        assert self.storage.file_exists(style_gcs_path), "Style JSON should exist in GCS"
+        for gcs_path in assets.values():
+            assert self.storage.file_exists(gcs_path), f"Asset {gcs_path} should exist in GCS"
+        
+        # Now test the style loading logic (inline version of _get_or_create_styles)
+        style_dir = os.path.join(self.temp_dir, "style")
+        os.makedirs(style_dir, exist_ok=True)
+        styles_path = os.path.join(style_dir, "styles.json")
+        
+        # This is the FIX: check job.style_params_gcs_path, not state_data
+        if job.style_params_gcs_path:
+            # Download style JSON
+            self.storage.download_file(job.style_params_gcs_path, styles_path)
+            
+            # Load and update paths
+            with open(styles_path, 'r') as f:
+                style_data = json.load(f)
+            
+            # Download assets and update paths
+            local_assets = {}
+            for asset_key, gcs_path in job.style_assets.items():
+                ext = os.path.splitext(gcs_path)[1] or '.png'
+                local_path = os.path.join(style_dir, f"{asset_key}{ext}")
+                self.storage.download_file(gcs_path, local_path)
+                local_assets[asset_key] = local_path
+            
+            # Update style_data with local paths
+            asset_mapping = {
+                'intro_background': ('intro', 'background_image'),
+                'karaoke_background': ('karaoke', 'background_image'),
+                'end_background': ('end', 'background_image'),
+                'font': [('intro', 'font'), ('karaoke', 'font_path'), ('end', 'font')],
+            }
+            
+            for asset_key, local_path in local_assets.items():
+                if asset_key in asset_mapping:
+                    mappings = asset_mapping[asset_key]
+                    if isinstance(mappings[0], str):
+                        mappings = [mappings]
+                    for section, field in mappings:
+                        if section in style_data:
+                            style_data[section][field] = local_path
+            
+            # Save updated styles
+            with open(styles_path, 'w') as f:
+                json.dump(style_data, f, indent=2)
+        
+        # Verify the result
+        with open(styles_path, 'r') as f:
+            result = json.load(f)
+        
+        # Check that paths were updated to local paths
+        assert style_dir in result['karaoke']['background_image'], \
+            f"karaoke.background_image should be local path, got: {result['karaoke']['background_image']}"
+        assert style_dir in result['karaoke']['font_path'], \
+            f"karaoke.font_path should be local path, got: {result['karaoke']['font_path']}"
+        assert style_dir in result['intro']['background_image'], \
+            f"intro.background_image should be local path"
+        
+        # Verify files actually exist locally
+        assert os.path.exists(result['karaoke']['background_image']), \
+            "Downloaded karaoke background should exist"
+        assert os.path.exists(result['karaoke']['font_path']), \
+            "Downloaded font should exist"
+        
+        print(f"\n✅ Style loading from job.style_params_gcs_path works!")
+        print(f"   karaoke.background_image: {result['karaoke']['background_image']}")
+        print(f"   karaoke.font_path: {result['karaoke']['font_path']}")
+    
+    def test_old_bug_state_data_lookup_fails(self):
+        """
+        Demonstrate that the OLD bug would fail to find styles.
+        
+        If we look at job.state_data['styles_gcs_path'] (the bug),
+        we won't find anything because styles are stored at 
+        job.style_params_gcs_path.
+        """
+        import time
+        job_id = f"test-bug-{int(time.time() * 1000)}"
+        
+        # Upload style to CORRECT location
+        style_gcs_path = f"uploads/{job_id}/style/style_params.json"
+        self.storage.upload_string('{"karaoke": {"font_size": 100}}', style_gcs_path)
+        
+        # Create job with styles in CORRECT location
+        job = MockJob(
+            job_id=job_id,
+            style_params_gcs_path=style_gcs_path,  # CORRECT location
+            style_assets={},
+            state_data={}  # No styles_gcs_path here!
+        )
+        
+        # THE BUG: looking in state_data instead of style_params_gcs_path
+        wrong_path = job.state_data.get('styles_gcs_path')
+        correct_path = job.style_params_gcs_path
+        
+        assert wrong_path is None, "state_data['styles_gcs_path'] should be None (the bug location)"
+        assert correct_path is not None, "style_params_gcs_path should have the correct path"
+        assert self.storage.file_exists(correct_path), "Style should exist at correct path"
+        
+        print(f"\n✅ Demonstrated the bug: state_data lookup returns None")
+        print(f"   state_data['styles_gcs_path'] = {wrong_path}")
+        print(f"   job.style_params_gcs_path = {correct_path}")
+    
+    def test_default_styles_when_no_custom_styles(self):
+        """Test that default styles are used when no custom styles provided."""
+        import time
+        job_id = f"test-default-{int(time.time() * 1000)}"
+        
+        # Job with NO custom styles
+        job = MockJob(
+            job_id=job_id,
+            style_params_gcs_path=None,
+            style_assets={},
+            state_data={}
+        )
+        
+        # Simulate the logic
+        style_dir = os.path.join(self.temp_dir, "style")
+        os.makedirs(style_dir, exist_ok=True)
+        styles_path = os.path.join(style_dir, "styles.json")
+        
+        if job.style_params_gcs_path:
+            # Would load custom styles
+            pass
+        else:
+            # Use default styles
+            default_styles = {
+                "karaoke": {
+                    "background_color": "#000000",
+                    "font": "Arial",
+                    "font_path": "",
+                    "font_size": 100
+                }
+            }
+            with open(styles_path, 'w') as f:
+                json.dump(default_styles, f, indent=2)
+        
+        # Verify defaults were used
+        with open(styles_path, 'r') as f:
+            result = json.load(f)
+        
+        assert result['karaoke']['background_color'] == "#000000"
+        assert result['karaoke']['font'] == "Arial"
+        
+        print(f"\n✅ Default styles used when no custom styles provided")
+
+
+class TestParallelWorkerExecution:
+    """
+    Tests for the parallel worker execution fix.
+    
+    The bug was: FastAPI's BackgroundTasks runs async tasks sequentially,
+    causing audio worker to complete before lyrics worker starts.
+    
+    The fix uses asyncio.gather() to run both workers in parallel.
+    """
+    
+    def test_asyncio_gather_runs_parallel(self):
+        """Test that asyncio.gather actually runs tasks in parallel."""
+        import asyncio
+        import time
+        
+        start_times = {}
+        end_times = {}
+        
+        async def task1():
+            start_times['task1'] = time.time()
+            await asyncio.sleep(0.1)
+            end_times['task1'] = time.time()
+            return "task1 done"
+        
+        async def task2():
+            start_times['task2'] = time.time()
+            await asyncio.sleep(0.1)
+            end_times['task2'] = time.time()
+            return "task2 done"
+        
+        async def run_parallel():
+            return await asyncio.gather(task1(), task2())
+        
+        overall_start = time.time()
+        results = asyncio.run(run_parallel())
+        overall_duration = time.time() - overall_start
+        
+        # Both tasks should have started at nearly the same time
+        start_diff = abs(start_times['task1'] - start_times['task2'])
+        
+        # If running in parallel:
+        # - Both start at ~same time (diff < 0.05s)
+        # - Total duration is ~0.1s (not 0.2s for sequential)
+        
+        assert start_diff < 0.05, \
+            f"Tasks should start together, diff was {start_diff:.3f}s"
+        assert overall_duration < 0.15, \
+            f"Parallel execution should take ~0.1s, took {overall_duration:.3f}s"
+        
+        print(f"\n✅ asyncio.gather runs tasks in parallel!")
+        print(f"   Task start time difference: {start_diff:.3f}s")
+        print(f"   Total duration: {overall_duration:.3f}s (sequential would be ~0.2s)")
+    
+    def test_sequential_background_tasks_is_slow(self):
+        """
+        Demonstrate that sequential execution (the bug) is slower.
+        """
+        import asyncio
+        import time
+        
+        execution_order = []
+        
+        async def task1():
+            execution_order.append(('task1', 'start'))
+            await asyncio.sleep(0.05)
+            execution_order.append(('task1', 'end'))
+        
+        async def task2():
+            execution_order.append(('task2', 'start'))
+            await asyncio.sleep(0.05)
+            execution_order.append(('task2', 'end'))
+        
+        # Sequential (the bug)
+        async def run_sequential():
+            await task1()
+            await task2()
+        
+        execution_order.clear()
+        start = time.time()
+        asyncio.run(run_sequential())
+        sequential_duration = time.time() - start
+        sequential_order = execution_order.copy()
+        
+        # Parallel (the fix)
+        async def run_parallel():
+            await asyncio.gather(task1(), task2())
+        
+        execution_order.clear()
+        start = time.time()
+        asyncio.run(run_parallel())
+        parallel_duration = time.time() - start
+        parallel_order = execution_order.copy()
+        
+        # Sequential: task1 starts, task1 ends, task2 starts, task2 ends
+        assert sequential_order[0] == ('task1', 'start')
+        assert sequential_order[1] == ('task1', 'end')
+        assert sequential_order[2] == ('task2', 'start')
+        
+        # Parallel: task1 starts, task2 starts (interleaved)
+        assert parallel_order[0][1] == 'start'
+        assert parallel_order[1][1] == 'start'
+        
+        # Parallel should be ~2x faster
+        assert parallel_duration < sequential_duration * 0.8, \
+            f"Parallel ({parallel_duration:.3f}s) should be faster than sequential ({sequential_duration:.3f}s)"
+        
+        print(f"\n✅ Demonstrated sequential vs parallel execution")
+        print(f"   Sequential: {sequential_duration:.3f}s - {sequential_order}")
+        print(f"   Parallel: {parallel_duration:.3f}s - {parallel_order}")
+
+
+print("✅ Style loading and parallel execution tests ready")

backend/tests/emulator/test_worker_logs_direct.py

@@ -0,0 +1,229 @@
+"""
+Direct tests for worker logging Firestore operations.
+
+These tests bypass the full app/worker imports and test the Firestore
+operations directly, avoiding dependency issues.
+
+Run with: ./scripts/run-emulator-tests.sh
+"""
+import pytest
+import time
+import requests
+import os
+import threading
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from datetime import datetime
+
+
+def emulators_running() -> bool:
+    """Check if GCP emulators are running."""
+    try:
+        requests.get("http://127.0.0.1:8080", timeout=1)
+        return True
+    except (requests.exceptions.ConnectionError, requests.exceptions.Timeout):
+        return False
+
+
+# Skip all tests in this module if emulators aren't running
+pytestmark = pytest.mark.skipif(
+    not emulators_running(),
+    reason="GCP emulators not running. Start with: scripts/start-emulators.sh"
+)
+
+# Set up environment for emulator
+os.environ["FIRESTORE_EMULATOR_HOST"] = "127.0.0.1:8080"
+os.environ["GOOGLE_CLOUD_PROJECT"] = "test-project"
+
+
+class TestWorkerLogsFirestoreDirect:
+    """Direct Firestore tests for worker logs - no app imports needed."""
+    
+    @pytest.fixture(autouse=True)
+    def setup_firestore(self):
+        """Set up Firestore client for each test."""
+        from google.cloud import firestore
+        self.db = firestore.Client(project="test-project")
+        self.collection = "test-worker-logs"
+        yield
+    
+    def _create_test_job(self):
+        """Create a test job document."""
+        job_id = f"test-{int(time.time() * 1000)}"
+        doc_ref = self.db.collection(self.collection).document(job_id)
+        doc_ref.set({
+            "job_id": job_id,
+            "status": "pending",
+            "created_at": datetime.utcnow(),
+            "worker_logs": []
+        })
+        return job_id
+    
+    def _append_log_read_modify_write(self, job_id: str, worker: str, message: str):
+        """
+        OLD METHOD: Read-modify-write (has race condition).
+        This is what we were doing before.
+        """
+        doc_ref = self.db.collection(self.collection).document(job_id)
+        doc = doc_ref.get()
+        if not doc.exists:
+            return
+        
+        data = doc.to_dict()
+        logs = data.get("worker_logs", [])
+        logs.append({
+            "timestamp": datetime.utcnow().isoformat() + "Z",
+            "level": "INFO",
+            "worker": worker,
+            "message": message
+        })
+        doc_ref.update({"worker_logs": logs})
+    
+    def _append_log_array_union(self, job_id: str, worker: str, message: str):
+        """
+        NEW METHOD: ArrayUnion (atomic, no race condition).
+        This is what we're doing now.
+        """
+        from google.cloud import firestore
+        doc_ref = self.db.collection(self.collection).document(job_id)
+        doc_ref.update({
+            "worker_logs": firestore.ArrayUnion([{
+                "timestamp": datetime.utcnow().isoformat() + "Z",
+                "level": "INFO",
+                "worker": worker,
+                "message": message
+            }])
+        })
+    
+    def _get_logs(self, job_id: str):
+        """Get logs from job document."""
+        doc_ref = self.db.collection(self.collection).document(job_id)
+        doc = doc_ref.get()
+        if not doc.exists:
+            return []
+        return doc.to_dict().get("worker_logs", [])
+    
+    def test_array_union_single_write(self):
+        """Test ArrayUnion works for single write."""
+        job_id = self._create_test_job()
+        
+        self._append_log_array_union(job_id, "test", "Single log message")
+        
+        time.sleep(0.1)
+        logs = self._get_logs(job_id)
+        
+        assert len(logs) == 1
+        assert logs[0]["message"] == "Single log message"
+        assert logs[0]["worker"] == "test"
+    
+    def test_array_union_sequential_writes(self):
+        """Test ArrayUnion preserves all sequential writes."""
+        job_id = self._create_test_job()
+        
+        for i in range(10):
+            self._append_log_array_union(job_id, "test", f"Log {i}")
+        
+        time.sleep(0.2)
+        logs = self._get_logs(job_id)
+        
+        assert len(logs) == 10, f"Expected 10 logs, got {len(logs)}"
+    
+    def test_read_modify_write_race_condition(self):
+        """
+        Demonstrate the race condition with read-modify-write.
+        This test shows WHY we needed ArrayUnion.
+        """
+        job_id = self._create_test_job()
+        num_writes = 20
+        
+        def write_log(index):
+            self._append_log_read_modify_write(job_id, "worker", f"RMW Log {index}")
+        
+        # Write concurrently - should lose some logs due to race condition
+        with ThreadPoolExecutor(max_workers=5) as executor:
+            futures = [executor.submit(write_log, i) for i in range(num_writes)]
+            for future in as_completed(futures):
+                try:
+                    future.result()
+                except Exception:
+                    pass  # Ignore errors for this test
+        
+        time.sleep(0.5)
+        logs = self._get_logs(job_id)
+        
+        # With read-modify-write, we likely lose some logs
+        # This is expected - the test documents the problem
+        rmw_count = len([l for l in logs if "RMW Log" in l.get("message", "")])
+        print(f"\nRead-modify-write: {rmw_count}/{num_writes} logs preserved")
+        
+        # We expect to lose some logs (this is the bug we're fixing)
+        # If all 20 are there, the race condition didn't trigger (which is fine)
+        # The important thing is that ArrayUnion test below ALWAYS preserves all
+    
+    def test_array_union_no_race_condition(self):
+        """
+        Verify ArrayUnion preserves ALL concurrent writes.
+        This is the critical test.
+        """
+        job_id = self._create_test_job()
+        num_writes = 20
+        
+        def write_log(index):
+            self._append_log_array_union(job_id, "worker", f"ArrayUnion Log {index}")
+        
+        # Write concurrently
+        with ThreadPoolExecutor(max_workers=5) as executor:
+            futures = [executor.submit(write_log, i) for i in range(num_writes)]
+            for future in as_completed(futures):
+                future.result()  # Raise any exceptions
+        
+        time.sleep(0.5)
+        logs = self._get_logs(job_id)
+        
+        # With ArrayUnion, ALL logs should be preserved
+        au_count = len([l for l in logs if "ArrayUnion Log" in l.get("message", "")])
+        print(f"\nArrayUnion: {au_count}/{num_writes} logs preserved")
+        
+        assert au_count == num_writes, \
+            f"ArrayUnion should preserve all {num_writes} logs, got {au_count}"
+    
+    def test_concurrent_workers_array_union(self):
+        """
+        Test simulating audio and lyrics workers writing concurrently.
+        """
+        job_id = self._create_test_job()
+        
+        def audio_worker():
+            for i in range(10):
+                self._append_log_array_union(job_id, "audio", f"Audio log {i}")
+                time.sleep(0.01)
+        
+        def lyrics_worker():
+            for i in range(10):
+                self._append_log_array_union(job_id, "lyrics", f"Lyrics log {i}")
+                time.sleep(0.01)
+        
+        # Start both workers
+        audio_thread = threading.Thread(target=audio_worker)
+        lyrics_thread = threading.Thread(target=lyrics_worker)
+        
+        audio_thread.start()
+        lyrics_thread.start()
+        
+        audio_thread.join()
+        lyrics_thread.join()
+        
+        time.sleep(0.5)
+        logs = self._get_logs(job_id)
+        
+        audio_logs = [l for l in logs if l.get("worker") == "audio"]
+        lyrics_logs = [l for l in logs if l.get("worker") == "lyrics"]
+        
+        print(f"\nConcurrent workers: {len(audio_logs)} audio + {len(lyrics_logs)} lyrics")
+        
+        assert len(audio_logs) == 10, f"Expected 10 audio logs, got {len(audio_logs)}"
+        assert len(lyrics_logs) == 10, f"Expected 10 lyrics logs, got {len(lyrics_logs)}"
+        
+        print("✅ All logs from both workers preserved!")
+
+
+print("✅ Direct Firestore worker logs tests ready")