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

backend/tests/test_jobs_api.py

@@ -0,0 +1,273 @@
+"""
+Unit tests for jobs.py API routes using FastAPI TestClient.
+
+These tests mock the underlying services and test the route logic directly.
+"""
+import pytest
+from datetime import datetime, UTC
+from unittest.mock import MagicMock, AsyncMock, patch
+from fastapi.testclient import TestClient
+
+from backend.models.job import Job, JobStatus
+
+
+@pytest.fixture
+def mock_job():
+    """Create a standard mock job for testing."""
+    return Job(
+        job_id="test123",
+        status=JobStatus.PENDING,
+        created_at=datetime.now(UTC),
+        updated_at=datetime.now(UTC),
+        artist="Test Artist",
+        title="Test Song"
+    )
+
+
+@pytest.fixture
+def mock_job_manager(mock_job):
+    """Create a mock JobManager with common methods."""
+    manager = MagicMock()
+    manager.get_job.return_value = mock_job
+    manager.list_jobs.return_value = [mock_job]
+    manager.create_job.return_value = mock_job
+    manager.delete_job.return_value = True
+    manager.cancel_job.return_value = mock_job
+    manager.update_job_status.return_value = None
+    manager.update_state_data.return_value = None
+    return manager
+
+
+@pytest.fixture
+def mock_worker_service():
+    """Create a mock WorkerService."""
+    service = MagicMock()
+    service.trigger_audio_worker = AsyncMock(return_value=True)
+    service.trigger_lyrics_worker = AsyncMock(return_value=True)
+    service.trigger_screens_worker = AsyncMock(return_value=True)
+    service.trigger_video_worker = AsyncMock(return_value=True)
+    return service
+
+
+@pytest.fixture
+def client(mock_job_manager, mock_worker_service):
+    """Create TestClient with mocked dependencies."""
+    mock_creds = MagicMock()
+    mock_creds.universe_domain = 'googleapis.com'
+
+    # Create a JobManager class that returns our mock instance
+    def mock_job_manager_factory(*args, **kwargs):
+        return mock_job_manager
+
+    # Patch at the module level where jobs.py imports them
+    # Also patch JobManager class used in dependencies.py for auth checks
+    with patch('backend.api.routes.jobs.job_manager', mock_job_manager), \
+         patch('backend.api.routes.jobs.worker_service', mock_worker_service), \
+         patch('backend.services.job_manager.JobManager', mock_job_manager_factory), \
+         patch('backend.services.firestore_service.firestore'), \
+         patch('backend.services.storage_service.storage'), \
+         patch('google.auth.default', return_value=(mock_creds, 'test-project')):
+        from backend.main import app
+        yield TestClient(app)
+
+
+class TestGetJob:
+    """Tests for GET /api/jobs/{job_id}."""
+    
+    def test_get_job_returns_200(self, client, mock_job_manager, mock_job, auth_headers):
+        """Test getting an existing job returns 200."""
+        response = client.get("/api/jobs/test123", headers=auth_headers)
+        assert response.status_code == 200
+    
+    def test_get_job_returns_job_data(self, client, mock_job_manager, mock_job, auth_headers):
+        """Test response contains job data."""
+        response = client.get("/api/jobs/test123", headers=auth_headers)
+        data = response.json()
+        assert data["job_id"] == "test123"
+        assert data["status"] == "pending"
+        assert data["artist"] == "Test Artist"
+    
+    def test_get_nonexistent_job_returns_404(self, mock_worker_service, auth_headers):
+        """Test getting non-existent job returns 404."""
+        mock_job_manager = MagicMock()
+        mock_job_manager.get_job.return_value = None
+        mock_creds = MagicMock()
+        mock_creds.universe_domain = 'googleapis.com'
+
+        def mock_job_manager_factory(*args, **kwargs):
+            return mock_job_manager
+
+        with patch('backend.api.routes.jobs.job_manager', mock_job_manager), \
+             patch('backend.api.routes.jobs.worker_service', mock_worker_service), \
+             patch('backend.services.job_manager.JobManager', mock_job_manager_factory), \
+             patch('backend.services.firestore_service.firestore'), \
+             patch('backend.services.storage_service.storage'), \
+             patch('google.auth.default', return_value=(mock_creds, 'test-project')):
+            from backend.main import app
+            client = TestClient(app)
+            response = client.get("/api/jobs/nonexistent", headers=auth_headers)
+            assert response.status_code == 404
+
+
+class TestListJobs:
+    """Tests for GET /api/jobs."""
+    
+    def test_list_jobs_returns_200(self, client, auth_headers):
+        """Test listing jobs returns 200."""
+        response = client.get("/api/jobs", headers=auth_headers)
+        assert response.status_code == 200
+    
+    def test_list_jobs_returns_array(self, client, mock_job_manager, auth_headers):
+        """Test response is an array of jobs."""
+        response = client.get("/api/jobs", headers=auth_headers)
+        data = response.json()
+        assert isinstance(data, list)
+        assert len(data) == 1
+        assert data[0]["job_id"] == "test123"
+    
+    def test_list_jobs_with_status_filter(self, client, mock_job_manager, auth_headers):
+        """Test listing jobs with status filter."""
+        response = client.get("/api/jobs?status=pending", headers=auth_headers)
+        assert response.status_code == 200
+    
+    def test_list_jobs_with_limit(self, client, mock_job_manager, auth_headers):
+        """Test listing jobs with limit."""
+        response = client.get("/api/jobs?limit=10", headers=auth_headers)
+        assert response.status_code == 200
+
+
+class TestCreateJob:
+    """Tests for POST /api/jobs."""
+    
+    def test_create_job_with_url_returns_200(self, client, mock_job_manager, auth_headers):
+        """Test creating job with URL returns 200."""
+        response = client.post(
+            "/api/jobs",
+            json={"url": "https://youtube.com/watch?v=test123"},
+            headers=auth_headers
+        )
+        assert response.status_code == 200
+    
+    def test_create_job_returns_job_id(self, client, mock_job_manager, auth_headers):
+        """Test create response contains job_id."""
+        response = client.post(
+            "/api/jobs",
+            json={"url": "https://youtube.com/watch?v=test"},
+            headers=auth_headers
+        )
+        data = response.json()
+        assert "job_id" in data
+    
+    def test_create_job_with_artist_title(self, client, mock_job_manager, auth_headers):
+        """Test creating job with artist and title."""
+        response = client.post(
+            "/api/jobs",
+            json={
+                "url": "https://youtube.com/watch?v=test",
+                "artist": "Test Artist",
+                "title": "Test Song"
+            },
+            headers=auth_headers
+        )
+        assert response.status_code == 200
+
+
+class TestDeleteJob:
+    """Tests for DELETE /api/jobs/{job_id}."""
+    
+    def test_delete_job_returns_200(self, client, mock_job_manager, auth_headers):
+        """Test deleting job returns 200."""
+        response = client.delete("/api/jobs/test123", headers=auth_headers)
+        assert response.status_code == 200
+    
+    def test_delete_nonexistent_job(self, mock_worker_service, auth_headers):
+        """Test deleting non-existent job."""
+        mock_job_manager = MagicMock()
+        mock_job_manager.get_job.return_value = None  # Job doesn't exist
+        mock_job_manager.delete_job.return_value = False
+        mock_creds = MagicMock()
+        mock_creds.universe_domain = 'googleapis.com'
+
+        def mock_job_manager_factory(*args, **kwargs):
+            return mock_job_manager
+
+        with patch('backend.api.routes.jobs.job_manager', mock_job_manager), \
+             patch('backend.api.routes.jobs.worker_service', mock_worker_service), \
+             patch('backend.services.job_manager.JobManager', mock_job_manager_factory), \
+             patch('backend.services.firestore_service.firestore'), \
+             patch('backend.services.storage_service.storage'), \
+             patch('google.auth.default', return_value=(mock_creds, 'test-project')):
+            from backend.main import app
+            client = TestClient(app)
+            response = client.delete("/api/jobs/nonexistent", headers=auth_headers)
+            # Either 200 or 404 depending on implementation
+            assert response.status_code in [200, 404]
+
+
+class TestCancelJob:
+    """Tests for POST /api/jobs/{job_id}/cancel."""
+    
+    def test_cancel_job_returns_200(self, client, mock_job_manager, mock_job, auth_headers):
+        """Test cancelling job returns 200."""
+        mock_job_manager.cancel_job.return_value = mock_job
+        response = client.post(
+            "/api/jobs/test123/cancel",
+            json={},
+            headers=auth_headers
+        )
+        assert response.status_code == 200
+
+
+class TestSubmitCorrections:
+    """Tests for POST /api/jobs/{job_id}/corrections."""
+    
+    def test_submit_corrections_returns_200(self, client, mock_job_manager, mock_job, auth_headers):
+        """Test submitting corrections returns 200."""
+        # Job needs to be in AWAITING_REVIEW or IN_REVIEW status
+        review_job = Job(
+            job_id="test123",
+            status=JobStatus.IN_REVIEW,
+            created_at=datetime.now(UTC),
+            updated_at=datetime.now(UTC),
+            artist="Test",
+            title="Test"
+        )
+        mock_job_manager.get_job.return_value = review_job
+        
+        response = client.post(
+            "/api/jobs/test123/corrections",
+            json={
+                "corrections": {
+                    "lines": [],
+                    "metadata": {"source": "test"}
+                }
+            },
+            headers=auth_headers
+        )
+        # Should be 200 or validation error
+        assert response.status_code in [200, 400, 422]
+
+
+class TestSelectInstrumental:
+    """Tests for POST /api/jobs/{job_id}/select-instrumental."""
+    
+    def test_select_instrumental_requires_selection_field(self, client, mock_job_manager, mock_job, auth_headers):
+        """Test instrumental selection requires selection field."""
+        response = client.post(
+            "/api/jobs/test123/select-instrumental",
+            json={},  # Missing selection field
+            headers=auth_headers
+        )
+        # Missing field should cause validation error
+        assert response.status_code == 422
+
+
+class TestStartReview:
+    """Tests for POST /api/jobs/{job_id}/start-review."""
+    
+    def test_start_review_endpoint_exists(self, client, mock_job_manager, mock_job, auth_headers):
+        """Test start review endpoint exists."""
+        response = client.post("/api/jobs/test123/start-review", headers=auth_headers)
+        # Should not be 404 or 405
+        assert response.status_code not in [404, 405]
+

backend/tests/test_local_encoding_service.py

@@ -0,0 +1,423 @@
+"""
+Tests for LocalEncodingService.
+
+Tests cover:
+- Service initialization
+- Hardware acceleration detection
+- FFmpeg command execution
+- Individual encoding methods
+- Full encoding pipeline
+- Dry run mode
+"""
+
+import os
+import tempfile
+import pytest
+from unittest.mock import MagicMock, patch, call
+
+from backend.services.local_encoding_service import (
+    LocalEncodingService,
+    EncodingConfig,
+    EncodingResult,
+    get_local_encoding_service,
+)
+
+
+class TestLocalEncodingServiceInit:
+    """Test service initialization."""
+
+    def test_init_default_values(self):
+        """Test default initialization."""
+        service = LocalEncodingService()
+        assert service.dry_run is False
+        assert "ffmpeg" in service._ffmpeg_base_command
+
+    def test_init_with_dry_run(self):
+        """Test initialization with dry run mode."""
+        service = LocalEncodingService(dry_run=True)
+        assert service.dry_run is True
+
+    def test_init_with_debug_logging(self):
+        """Test initialization with debug logging level."""
+        import logging
+        service = LocalEncodingService(log_level=logging.DEBUG)
+        assert "-loglevel verbose" in service._ffmpeg_base_command
+
+    def test_init_with_info_logging(self):
+        """Test initialization with info logging level."""
+        import logging
+        service = LocalEncodingService(log_level=logging.INFO)
+        assert "-loglevel fatal" in service._ffmpeg_base_command
+
+
+class TestLocalEncodingServiceHWAccel:
+    """Test hardware acceleration detection."""
+
+    @patch("subprocess.run")
+    def test_detect_nvenc_available(self, mock_run):
+        """Test NVENC detection when available."""
+        mock_run.return_value = MagicMock(returncode=0)
+
+        service = LocalEncodingService()
+        # Force detection
+        service._detect_and_set_hwaccel()
+
+        assert service._hwaccel_available is True
+        assert service._video_encoder == "h264_nvenc"
+        assert service._scale_filter == "scale_cuda"
+
+    @patch("subprocess.run")
+    def test_detect_no_hwaccel(self, mock_run):
+        """Test fallback when no hardware acceleration available."""
+        import subprocess
+        mock_run.side_effect = subprocess.CalledProcessError(1, "test")
+
+        service = LocalEncodingService()
+        # Force detection
+        service._detect_and_set_hwaccel()
+
+        assert service._hwaccel_available is False
+        assert service._video_encoder == "libx264"
+        assert service._scale_filter == "scale"
+
+    def test_nvenc_quality_settings(self):
+        """Test NVENC quality settings for different presets."""
+        service = LocalEncodingService()
+        service._hwaccel_available = True
+
+        lossless = service._get_nvenc_quality_settings("lossless")
+        assert "cq 0" in lossless
+
+        medium = service._get_nvenc_quality_settings("medium")
+        assert "p4" in medium
+
+    def test_nvenc_quality_settings_disabled(self):
+        """Test NVENC quality settings when hwaccel is disabled."""
+        service = LocalEncodingService()
+        service._hwaccel_available = False
+
+        settings = service._get_nvenc_quality_settings("lossless")
+        assert settings == ""
+
+
+class TestLocalEncodingServiceExecuteCommand:
+    """Test command execution."""
+
+    @patch("subprocess.run")
+    def test_execute_command_success(self, mock_run):
+        """Test successful command execution."""
+        mock_run.return_value = MagicMock(returncode=0)
+
+        service = LocalEncodingService()
+        result = service._execute_command("echo test", "Test command")
+
+        assert result is True
+        mock_run.assert_called_once()
+
+    @patch("subprocess.run")
+    def test_execute_command_failure(self, mock_run):
+        """Test command execution failure."""
+        import subprocess
+        mock_run.side_effect = subprocess.CalledProcessError(
+            1, "test", stderr="Error message"
+        )
+
+        service = LocalEncodingService()
+        result = service._execute_command("echo test", "Test command")
+
+        assert result is False
+
+    @patch("subprocess.run")
+    def test_execute_command_timeout(self, mock_run):
+        """Test command execution timeout."""
+        import subprocess
+        mock_run.side_effect = subprocess.TimeoutExpired("test", 30)
+
+        service = LocalEncodingService()
+        result = service._execute_command("echo test", "Test command", timeout=30)
+
+        assert result is False
+
+    def test_execute_command_dry_run(self):
+        """Test command execution in dry run mode."""
+        service = LocalEncodingService(dry_run=True)
+        result = service._execute_command("echo test", "Test command")
+
+        assert result is True
+        # No actual subprocess should be called in dry run mode
+
+
+class TestLocalEncodingServiceEncodingMethods:
+    """Test individual encoding methods."""
+
+    @patch.object(LocalEncodingService, "_execute_command")
+    def test_remux_with_instrumental(self, mock_execute):
+        """Test remuxing with instrumental audio."""
+        mock_execute.return_value = True
+
+        service = LocalEncodingService()
+        result = service.remux_with_instrumental(
+            "/input/video.mov",
+            "/input/audio.flac",
+            "/output/video.mp4"
+        )
+
+        assert result is True
+        mock_execute.assert_called_once()
+        call_args = mock_execute.call_args[0][0]
+        assert "/input/video.mov" in call_args
+        assert "/input/audio.flac" in call_args
+        assert "-map 0:v -map 1:a" in call_args
+
+    @patch.object(LocalEncodingService, "_execute_command_with_fallback")
+    def test_convert_mov_to_mp4(self, mock_execute):
+        """Test MOV to MP4 conversion."""
+        mock_execute.return_value = True
+
+        service = LocalEncodingService()
+        result = service.convert_mov_to_mp4(
+            "/input/video.mov",
+            "/output/video.mp4"
+        )
+
+        assert result is True
+        mock_execute.assert_called_once()
+
+    @patch.object(LocalEncodingService, "_execute_command_with_fallback")
+    def test_encode_lossless_mp4_without_end(self, mock_execute):
+        """Test lossless 4K MP4 encoding without end credits."""
+        mock_execute.return_value = True
+
+        service = LocalEncodingService()
+        result = service.encode_lossless_mp4(
+            "/input/title.mov",
+            "/input/karaoke.mp4",
+            "/output/lossless.mp4"
+        )
+
+        assert result is True
+        mock_execute.assert_called_once()
+        call_args = mock_execute.call_args
+        assert "concat=n=2" in call_args[0][0]  # GPU command
+
+    @patch.object(LocalEncodingService, "_execute_command_with_fallback")
+    def test_encode_lossless_mp4_with_end(self, mock_execute):
+        """Test lossless 4K MP4 encoding with end credits."""
+        mock_execute.return_value = True
+
+        with tempfile.TemporaryDirectory() as tmpdir:
+            end_file = os.path.join(tmpdir, "end.mov")
+            with open(end_file, "w") as f:
+                f.write("fake video")
+
+            service = LocalEncodingService()
+            result = service.encode_lossless_mp4(
+                "/input/title.mov",
+                "/input/karaoke.mp4",
+                "/output/lossless.mp4",
+                end_video=end_file
+            )
+
+            assert result is True
+            call_args = mock_execute.call_args
+            assert "concat=n=3" in call_args[0][0]  # 3 videos
+
+    @patch.object(LocalEncodingService, "_execute_command")
+    def test_encode_lossy_mp4(self, mock_execute):
+        """Test lossy 4K MP4 encoding."""
+        mock_execute.return_value = True
+
+        service = LocalEncodingService()
+        result = service.encode_lossy_mp4(
+            "/input/lossless.mp4",
+            "/output/lossy.mp4"
+        )
+
+        assert result is True
+        call_args = mock_execute.call_args[0][0]
+        assert "-c:v copy" in call_args
+        assert "aac" in call_args.lower()
+
+    @patch.object(LocalEncodingService, "_execute_command")
+    def test_encode_lossless_mkv(self, mock_execute):
+        """Test MKV encoding with FLAC audio."""
+        mock_execute.return_value = True
+
+        service = LocalEncodingService()
+        result = service.encode_lossless_mkv(
+            "/input/lossless.mp4",
+            "/output/video.mkv"
+        )
+
+        assert result is True
+        call_args = mock_execute.call_args[0][0]
+        assert "-c:v copy" in call_args
+        assert "-c:a flac" in call_args
+
+    @patch.object(LocalEncodingService, "_execute_command_with_fallback")
+    def test_encode_720p(self, mock_execute):
+        """Test 720p encoding."""
+        mock_execute.return_value = True
+
+        service = LocalEncodingService()
+        result = service.encode_720p(
+            "/input/lossless.mp4",
+            "/output/720p.mp4"
+        )
+
+        assert result is True
+        call_args = mock_execute.call_args
+        # Should contain scale filter
+        assert "1280:720" in call_args[0][0] or "1280:720" in call_args[0][1]
+
+
+class TestLocalEncodingServiceFullPipeline:
+    """Test full encoding pipeline."""
+
+    @patch.object(LocalEncodingService, "remux_with_instrumental")
+    @patch.object(LocalEncodingService, "convert_mov_to_mp4")
+    @patch.object(LocalEncodingService, "encode_lossless_mp4")
+    @patch.object(LocalEncodingService, "encode_lossy_mp4")
+    @patch.object(LocalEncodingService, "encode_lossless_mkv")
+    @patch.object(LocalEncodingService, "encode_720p")
+    def test_encode_all_formats_success(
+        self, mock_720p, mock_mkv, mock_lossy, mock_lossless, mock_convert, mock_remux
+    ):
+        """Test successful full encoding pipeline."""
+        mock_remux.return_value = True
+        mock_convert.return_value = True
+        mock_lossless.return_value = True
+        mock_lossy.return_value = True
+        mock_mkv.return_value = True
+        mock_720p.return_value = True
+
+        service = LocalEncodingService()
+        config = EncodingConfig(
+            title_video="/input/title.mov",
+            karaoke_video="/input/karaoke.mov",
+            instrumental_audio="/input/instrumental.flac",
+            output_karaoke_mp4="/output/karaoke.mp4",
+            output_with_vocals_mp4="/output/with_vocals.mp4",
+            output_lossless_4k_mp4="/output/lossless_4k.mp4",
+            output_lossy_4k_mp4="/output/lossy_4k.mp4",
+            output_lossless_mkv="/output/lossless.mkv",
+            output_720p_mp4="/output/720p.mp4",
+        )
+
+        result = service.encode_all_formats(config)
+
+        assert result.success is True
+        assert "karaoke_mp4" in result.output_files
+        assert "lossless_4k_mp4" in result.output_files
+        assert "720p_mp4" in result.output_files
+
+    @patch.object(LocalEncodingService, "remux_with_instrumental")
+    def test_encode_all_formats_failure_early(self, mock_remux):
+        """Test encoding pipeline failure at early step."""
+        mock_remux.return_value = False
+
+        service = LocalEncodingService()
+        config = EncodingConfig(
+            title_video="/input/title.mov",
+            karaoke_video="/input/karaoke.mov",
+            instrumental_audio="/input/instrumental.flac",
+            output_karaoke_mp4="/output/karaoke.mp4",
+            output_lossless_4k_mp4="/output/lossless_4k.mp4",
+        )
+
+        result = service.encode_all_formats(config)
+
+        assert result.success is False
+        assert "Failed to remux" in result.error
+
+    def test_encode_all_formats_dry_run(self):
+        """Test encoding pipeline in dry run mode."""
+        service = LocalEncodingService(dry_run=True)
+        config = EncodingConfig(
+            title_video="/input/title.mov",
+            karaoke_video="/input/karaoke.mp4",  # Already MP4
+            instrumental_audio="/input/instrumental.flac",
+            output_karaoke_mp4="/output/karaoke.mp4",
+            output_lossless_4k_mp4="/output/lossless_4k.mp4",
+            output_lossy_4k_mp4="/output/lossy_4k.mp4",
+            output_lossless_mkv="/output/lossless.mkv",
+            output_720p_mp4="/output/720p.mp4",
+        )
+
+        result = service.encode_all_formats(config)
+
+        # In dry run mode, all operations should "succeed"
+        assert result.success is True
+
+
+class TestEncodingConfig:
+    """Test EncodingConfig dataclass."""
+
+    def test_config_required_fields(self):
+        """Test that required fields must be provided."""
+        config = EncodingConfig(
+            title_video="/path/title.mov",
+            karaoke_video="/path/karaoke.mov",
+            instrumental_audio="/path/audio.flac",
+        )
+        assert config.title_video == "/path/title.mov"
+        assert config.end_video is None  # Optional field
+
+    def test_config_all_fields(self):
+        """Test config with all fields."""
+        config = EncodingConfig(
+            title_video="/path/title.mov",
+            karaoke_video="/path/karaoke.mov",
+            instrumental_audio="/path/audio.flac",
+            end_video="/path/end.mov",
+            output_karaoke_mp4="/output/karaoke.mp4",
+            output_720p_mp4="/output/720p.mp4",
+        )
+        assert config.end_video == "/path/end.mov"
+        assert config.output_karaoke_mp4 == "/output/karaoke.mp4"
+
+
+class TestEncodingResult:
+    """Test EncodingResult dataclass."""
+
+    def test_result_success(self):
+        """Test successful result."""
+        result = EncodingResult(
+            success=True,
+            output_files={"key": "/path/file.mp4"}
+        )
+        assert result.success is True
+        assert result.error is None
+
+    def test_result_failure(self):
+        """Test failure result."""
+        result = EncodingResult(
+            success=False,
+            output_files={},
+            error="Something went wrong"
+        )
+        assert result.success is False
+        assert result.error == "Something went wrong"
+
+
+class TestGetLocalEncodingService:
+    """Test factory function."""
+
+    def test_get_service_creates_instance(self):
+        """Test that factory function creates a new instance."""
+        import backend.services.local_encoding_service as module
+        module._local_encoding_service = None
+
+        service = get_local_encoding_service()
+
+        assert service is not None
+        assert isinstance(service, LocalEncodingService)
+
+    def test_get_service_with_dry_run(self):
+        """Test factory function with dry run option."""
+        import backend.services.local_encoding_service as module
+        module._local_encoding_service = None
+
+        service = get_local_encoding_service(dry_run=True)
+
+        assert service.dry_run is True