karaoke-gen 0.103.1__py3-none-any.whl → 0.105.4__py3-none-any.whl

backend/tests/test_admin_delete_outputs.py

@@ -0,0 +1,352 @@
+"""
+Unit tests for admin delete job outputs endpoint.
+
+Tests the POST /api/admin/jobs/{job_id}/delete-outputs endpoint that allows admins
+to delete distributed outputs (YouTube, Dropbox, Google Drive) while preserving
+the job record.
+"""
+import pytest
+from unittest.mock import Mock, patch, MagicMock
+from fastapi.testclient import TestClient
+from fastapi import FastAPI
+from datetime import datetime
+
+from backend.api.routes.admin import router
+from backend.api.dependencies import require_admin
+from backend.models.job import Job, JobStatus
+
+
+# Create a test app with the admin router
+app = FastAPI()
+app.include_router(router, prefix="/api")
+
+
+def get_mock_admin():
+    """Override for require_admin dependency."""
+    from backend.api.dependencies import AuthResult, UserType
+    return AuthResult(
+        is_valid=True,
+        user_type=UserType.ADMIN,
+        remaining_uses=999,
+        message="Admin authenticated",
+        user_email="admin@example.com",
+        is_admin=True,
+    )
+
+
+# Override the require_admin dependency
+app.dependency_overrides[require_admin] = get_mock_admin
+
+
+@pytest.fixture
+def client():
+    """Create a test client."""
+    return TestClient(app)
+
+
+@pytest.fixture
+def mock_complete_job():
+    """Create a mock job in COMPLETE status with distribution data."""
+    job = Mock(spec=Job)
+    job.job_id = "test-job-123"
+    job.user_email = "user@example.com"
+    job.artist = "Test Artist"
+    job.title = "Test Title"
+    job.status = "complete"
+    job.dropbox_path = "/Karaoke/Organized"
+    job.outputs_deleted_at = None
+    job.outputs_deleted_by = None
+    job.state_data = {
+        "youtube_url": "https://youtu.be/abc123",
+        "brand_code": "NOMAD-1234",
+        "dropbox_link": "https://dropbox.com/...",
+        "gdrive_files": {"mp4": "file_id_1", "mp4_720p": "file_id_2"},
+    }
+    job.timeline = []
+    return job
+
+
+@pytest.fixture
+def mock_job_no_outputs():
+    """Create a mock job in COMPLETE status without distribution data."""
+    job = Mock(spec=Job)
+    job.job_id = "test-job-456"
+    job.user_email = "user@example.com"
+    job.artist = "Test Artist"
+    job.title = "Test Title"
+    job.status = "complete"
+    job.dropbox_path = None
+    job.outputs_deleted_at = None
+    job.outputs_deleted_by = None
+    job.state_data = {}
+    job.timeline = []
+    return job
+
+
+class TestDeleteOutputsSuccess:
+    """Tests for successful output deletion."""
+
+    def test_delete_outputs_success(self, client, mock_complete_job):
+        """Test successfully deleting outputs from a complete job."""
+        with patch('backend.api.routes.admin.JobManager') as mock_jm_class, \
+             patch('backend.api.routes.admin.get_user_service') as mock_user_service:
+            mock_jm = Mock()
+            mock_jm.get_job.return_value = mock_complete_job
+            mock_jm_class.return_value = mock_jm
+
+            # Mock Firestore
+            mock_db = Mock()
+            mock_job_ref = Mock()
+            mock_db.collection.return_value.document.return_value = mock_job_ref
+            mock_user_service.return_value.db = mock_db
+
+            response = client.post("/api/admin/jobs/test-job-123/delete-outputs")
+
+            assert response.status_code == 200
+            data = response.json()
+            assert data["status"] == "success"
+            assert data["job_id"] == "test-job-123"
+            assert "outputs_deleted_at" in data
+
+    def test_delete_outputs_clears_state_data_keys(self, client, mock_complete_job):
+        """Test that output-related state_data keys are listed as cleared."""
+        with patch('backend.api.routes.admin.JobManager') as mock_jm_class, \
+             patch('backend.api.routes.admin.get_user_service') as mock_user_service:
+            mock_jm = Mock()
+            mock_jm.get_job.return_value = mock_complete_job
+            mock_jm_class.return_value = mock_jm
+
+            # Mock Firestore
+            mock_db = Mock()
+            mock_job_ref = Mock()
+            mock_db.collection.return_value.document.return_value = mock_job_ref
+            mock_user_service.return_value.db = mock_db
+
+            response = client.post("/api/admin/jobs/test-job-123/delete-outputs")
+
+            assert response.status_code == 200
+            data = response.json()
+            # Should list cleared keys
+            assert "youtube_url" in data["cleared_state_data"]
+            assert "brand_code" in data["cleared_state_data"]
+            assert "dropbox_link" in data["cleared_state_data"]
+            assert "gdrive_files" in data["cleared_state_data"]
+
+    def test_delete_outputs_job_without_distribution(self, client, mock_job_no_outputs):
+        """Test deleting outputs from job that has no distribution data."""
+        with patch('backend.api.routes.admin.JobManager') as mock_jm_class, \
+             patch('backend.api.routes.admin.get_user_service') as mock_user_service:
+            mock_jm = Mock()
+            mock_jm.get_job.return_value = mock_job_no_outputs
+            mock_jm_class.return_value = mock_jm
+
+            # Mock Firestore
+            mock_db = Mock()
+            mock_job_ref = Mock()
+            mock_db.collection.return_value.document.return_value = mock_job_ref
+            mock_user_service.return_value.db = mock_db
+
+            response = client.post("/api/admin/jobs/test-job-456/delete-outputs")
+
+            assert response.status_code == 200
+            data = response.json()
+            assert data["status"] == "success"
+            # All services should be skipped
+            assert data["deleted_services"]["youtube"]["status"] == "skipped"
+            assert data["deleted_services"]["dropbox"]["status"] == "skipped"
+            assert data["deleted_services"]["gdrive"]["status"] == "skipped"
+            # No keys to clear
+            assert data["cleared_state_data"] == []
+
+
+class TestDeleteOutputsValidation:
+    """Tests for validation on delete outputs endpoint."""
+
+    def test_rejects_non_terminal_status(self, client, mock_complete_job):
+        """Test that jobs not in terminal states are rejected."""
+        mock_complete_job.status = "encoding"
+
+        with patch('backend.api.routes.admin.JobManager') as mock_jm_class:
+            mock_jm = Mock()
+            mock_jm.get_job.return_value = mock_complete_job
+            mock_jm_class.return_value = mock_jm
+
+            response = client.post("/api/admin/jobs/test-job-123/delete-outputs")
+
+            assert response.status_code == 400
+            assert "terminal" in response.json()["detail"].lower()
+
+    def test_rejects_awaiting_review_status(self, client, mock_complete_job):
+        """Test that AWAITING_REVIEW is rejected (not terminal)."""
+        mock_complete_job.status = "awaiting_review"
+
+        with patch('backend.api.routes.admin.JobManager') as mock_jm_class:
+            mock_jm = Mock()
+            mock_jm.get_job.return_value = mock_complete_job
+            mock_jm_class.return_value = mock_jm
+
+            response = client.post("/api/admin/jobs/test-job-123/delete-outputs")
+
+            assert response.status_code == 400
+
+    def test_accepts_prep_complete_status(self, client, mock_complete_job):
+        """Test that prep_complete is accepted as terminal."""
+        mock_complete_job.status = "prep_complete"
+
+        with patch('backend.api.routes.admin.JobManager') as mock_jm_class, \
+             patch('backend.api.routes.admin.get_user_service') as mock_user_service:
+            mock_jm = Mock()
+            mock_jm.get_job.return_value = mock_complete_job
+            mock_jm_class.return_value = mock_jm
+
+            mock_db = Mock()
+            mock_job_ref = Mock()
+            mock_db.collection.return_value.document.return_value = mock_job_ref
+            mock_user_service.return_value.db = mock_db
+
+            response = client.post("/api/admin/jobs/test-job-123/delete-outputs")
+
+            assert response.status_code == 200
+
+    def test_accepts_failed_status(self, client, mock_complete_job):
+        """Test that failed is accepted as terminal."""
+        mock_complete_job.status = "failed"
+
+        with patch('backend.api.routes.admin.JobManager') as mock_jm_class, \
+             patch('backend.api.routes.admin.get_user_service') as mock_user_service:
+            mock_jm = Mock()
+            mock_jm.get_job.return_value = mock_complete_job
+            mock_jm_class.return_value = mock_jm
+
+            mock_db = Mock()
+            mock_job_ref = Mock()
+            mock_db.collection.return_value.document.return_value = mock_job_ref
+            mock_user_service.return_value.db = mock_db
+
+            response = client.post("/api/admin/jobs/test-job-123/delete-outputs")
+
+            assert response.status_code == 200
+
+    def test_rejects_already_deleted(self, client, mock_complete_job):
+        """Test that already-deleted outputs cannot be deleted again."""
+        mock_complete_job.outputs_deleted_at = datetime(2026, 1, 9, 12, 0, 0)
+
+        with patch('backend.api.routes.admin.JobManager') as mock_jm_class:
+            mock_jm = Mock()
+            mock_jm.get_job.return_value = mock_complete_job
+            mock_jm_class.return_value = mock_jm
+
+            response = client.post("/api/admin/jobs/test-job-123/delete-outputs")
+
+            assert response.status_code == 400
+            assert "already deleted" in response.json()["detail"].lower()
+
+    def test_returns_404_for_missing_job(self, client):
+        """Test 404 when job doesn't exist."""
+        with patch('backend.api.routes.admin.JobManager') as mock_jm_class:
+            mock_jm = Mock()
+            mock_jm.get_job.return_value = None
+            mock_jm_class.return_value = mock_jm
+
+            response = client.post("/api/admin/jobs/nonexistent/delete-outputs")
+
+            assert response.status_code == 404
+            assert "not found" in response.json()["detail"].lower()
+
+
+class TestDeleteOutputsServices:
+    """Tests for service deletion behavior."""
+
+    def test_handles_missing_youtube(self, client, mock_complete_job):
+        """Test handling when job has no YouTube URL."""
+        mock_complete_job.state_data = {"brand_code": "NOMAD-1234"}
+
+        with patch('backend.api.routes.admin.JobManager') as mock_jm_class, \
+             patch('backend.api.routes.admin.get_user_service') as mock_user_service:
+            mock_jm = Mock()
+            mock_jm.get_job.return_value = mock_complete_job
+            mock_jm_class.return_value = mock_jm
+
+            mock_db = Mock()
+            mock_job_ref = Mock()
+            mock_db.collection.return_value.document.return_value = mock_job_ref
+            mock_user_service.return_value.db = mock_db
+
+            response = client.post("/api/admin/jobs/test-job-123/delete-outputs")
+
+            assert response.status_code == 200
+            data = response.json()
+            assert data["deleted_services"]["youtube"]["status"] == "skipped"
+
+    def test_handles_missing_dropbox_path(self, client, mock_complete_job):
+        """Test handling when job has no dropbox_path."""
+        mock_complete_job.dropbox_path = None
+        mock_complete_job.state_data = {"youtube_url": "https://youtu.be/abc123"}
+
+        with patch('backend.api.routes.admin.JobManager') as mock_jm_class, \
+             patch('backend.api.routes.admin.get_user_service') as mock_user_service:
+            mock_jm = Mock()
+            mock_jm.get_job.return_value = mock_complete_job
+            mock_jm_class.return_value = mock_jm
+
+            mock_db = Mock()
+            mock_job_ref = Mock()
+            mock_db.collection.return_value.document.return_value = mock_job_ref
+            mock_user_service.return_value.db = mock_db
+
+            response = client.post("/api/admin/jobs/test-job-123/delete-outputs")
+
+            assert response.status_code == 200
+            data = response.json()
+            assert data["deleted_services"]["dropbox"]["status"] == "skipped"
+
+
+class TestDeleteOutputsLogging:
+    """Tests for logging on delete outputs endpoint."""
+
+    def test_logs_admin_action(self, client, mock_complete_job):
+        """Test that admin delete action is logged."""
+        with patch('backend.api.routes.admin.JobManager') as mock_jm_class, \
+             patch('backend.api.routes.admin.get_user_service') as mock_user_service, \
+             patch('backend.api.routes.admin.logger') as mock_logger:
+            mock_jm = Mock()
+            mock_jm.get_job.return_value = mock_complete_job
+            mock_jm_class.return_value = mock_jm
+
+            mock_db = Mock()
+            mock_job_ref = Mock()
+            mock_db.collection.return_value.document.return_value = mock_job_ref
+            mock_user_service.return_value.db = mock_db
+
+            response = client.post("/api/admin/jobs/test-job-123/delete-outputs")
+
+            assert response.status_code == 200
+            mock_logger.info.assert_called()
+            log_message = mock_logger.info.call_args[0][0]
+            assert "admin" in log_message.lower() or "deleted" in log_message.lower()
+
+
+class TestDeleteOutputsAuthorization:
+    """Tests for authorization on the delete outputs endpoint."""
+
+    def test_requires_admin_access(self, client, mock_complete_job):
+        """Test that non-admin users cannot access the endpoint."""
+        original_override = app.dependency_overrides.get(require_admin)
+
+        def get_non_admin():
+            from fastapi import HTTPException
+            raise HTTPException(status_code=403, detail="Admin access required")
+
+        app.dependency_overrides[require_admin] = get_non_admin
+
+        try:
+            response = client.post(
+                "/api/admin/jobs/test-job-123/delete-outputs",
+                headers={"Authorization": "Bearer user-token"}
+            )
+            assert response.status_code == 403
+        finally:
+            if original_override:
+                app.dependency_overrides[require_admin] = original_override
+            else:
+                app.dependency_overrides[require_admin] = get_mock_admin

backend/tests/test_gce_encoding_worker.py

@@ -0,0 +1,229 @@
+"""
+Tests for GCE Encoding Worker (gce_encoding/main.py).
+
+These tests verify the file-finding logic in the GCE encoding worker,
+particularly ensuring that instrumental selection is respected.
+
+NOTE: This test file is self-contained and doesn't import the full app
+to avoid dependency issues in CI/CD environments.
+"""
+
+import pytest
+from pathlib import Path
+
+
+# Copy the find_file function here to test it in isolation
+# This avoids importing the full gce_encoding module which has GCS dependencies
+def find_file(work_dir: Path, *patterns):
+    '''Find a file matching any of the given glob patterns.'''
+    for pattern in patterns:
+        matches = list(work_dir.glob(f"**/{pattern}"))
+        if matches:
+            return matches[0]
+    return None
+
+
+class TestFindFile:
+    """Test the find_file function used to locate input files."""
+
+    def test_find_file_single_match(self, tmp_path):
+        """Test finding a file with a single match."""
+        # Create test file
+        test_file = tmp_path / "test_instrumental.flac"
+        test_file.touch()
+
+        result = find_file(tmp_path, "*instrumental*.flac")
+        assert result is not None
+        assert result.name == "test_instrumental.flac"
+
+    def test_find_file_no_match(self, tmp_path):
+        """Test finding a file with no matches returns None."""
+        result = find_file(tmp_path, "*nonexistent*.flac")
+        assert result is None
+
+    def test_find_file_priority_order(self, tmp_path):
+        """Test that find_file returns first matching pattern."""
+        # Create multiple files that match different patterns
+        first = tmp_path / "first_pattern.flac"
+        second = tmp_path / "second_pattern.flac"
+        first.touch()
+        second.touch()
+
+        # First pattern should win
+        result = find_file(tmp_path, "*first*.flac", "*second*.flac")
+        assert result.name == "first_pattern.flac"
+
+
+class TestInstrumentalSelection:
+    """Test that instrumental selection is properly respected."""
+
+    def test_clean_instrumental_prioritized_when_selected(self, tmp_path):
+        """Test that clean instrumental is found when 'clean' is selected.
+
+        When both instrumentals exist and 'clean' is selected,
+        the clean version should be found.
+        """
+        # Create both instrumental files (as they exist in GCS)
+        clean = tmp_path / "Artist - Title (Instrumental Clean).flac"
+        backing = tmp_path / "Artist - Title (Instrumental Backing).flac"
+        clean.touch()
+        backing.touch()
+
+        # Simulate finding instrumental with 'clean' selection
+        # (mimics the logic in run_encoding when instrumental_selection == 'clean')
+        result = find_file(
+            tmp_path,
+            "*instrumental_clean*.flac", "*Instrumental Clean*.flac",
+            "*instrumental*.flac", "*Instrumental*.flac",
+            "*instrumental*.wav"
+        )
+
+        assert result is not None
+        assert "Clean" in result.name
+
+    def test_backing_instrumental_prioritized_when_selected(self, tmp_path):
+        """Test that backing instrumental is found when 'with_backing' is selected.
+
+        When both instrumentals exist and 'with_backing' is selected,
+        the backing version should be found.
+
+        This test would have caught the bug where the GCE worker always
+        used the clean instrumental regardless of user selection.
+        """
+        # Create both instrumental files (as they exist in GCS)
+        clean = tmp_path / "Artist - Title (Instrumental Clean).flac"
+        backing = tmp_path / "Artist - Title (Instrumental Backing).flac"
+        clean.touch()
+        backing.touch()
+
+        # Simulate finding instrumental with 'with_backing' selection
+        # (mimics the logic in run_encoding when instrumental_selection == 'with_backing')
+        result = find_file(
+            tmp_path,
+            "*instrumental_with_backing*.flac", "*Instrumental Backing*.flac",
+            "*with_backing*.flac", "*Backing*.flac",
+            "*instrumental*.flac", "*Instrumental*.flac",
+            "*instrumental*.wav"
+        )
+
+        assert result is not None
+        assert "Backing" in result.name
+
+    def test_backing_instrumental_with_stem_naming(self, tmp_path):
+        """Test finding backing instrumental with GCS stem naming convention.
+
+        In GCS, stems are named like 'stems/instrumental_with_backing.flac'
+        """
+        stems_dir = tmp_path / "stems"
+        stems_dir.mkdir()
+
+        clean = stems_dir / "instrumental_clean.flac"
+        backing = stems_dir / "instrumental_with_backing.flac"
+        clean.touch()
+        backing.touch()
+
+        # Simulate finding instrumental with 'with_backing' selection
+        result = find_file(
+            tmp_path,
+            "*instrumental_with_backing*.flac", "*Instrumental Backing*.flac",
+            "*with_backing*.flac", "*Backing*.flac",
+            "*instrumental*.flac", "*Instrumental*.flac",
+            "*instrumental*.wav"
+        )
+
+        assert result is not None
+        assert "with_backing" in result.name
+
+    def test_fallback_to_generic_when_specific_not_found(self, tmp_path):
+        """Test fallback to generic pattern when specific not found."""
+        # Only create a generically named instrumental
+        generic = tmp_path / "instrumental.flac"
+        generic.touch()
+
+        # Both clean and backing selections should fall back
+        for selection in ["clean", "with_backing"]:
+            if selection == "with_backing":
+                patterns = (
+                    "*instrumental_with_backing*.flac", "*Instrumental Backing*.flac",
+                    "*with_backing*.flac", "*Backing*.flac",
+                    "*instrumental*.flac", "*Instrumental*.flac",
+                    "*instrumental*.wav"
+                )
+            else:
+                patterns = (
+                    "*instrumental_clean*.flac", "*Instrumental Clean*.flac",
+                    "*instrumental*.flac", "*Instrumental*.flac",
+                    "*instrumental*.wav"
+                )
+
+            result = find_file(tmp_path, *patterns)
+            assert result is not None
+            assert result.name == "instrumental.flac"
+
+
+class TestInstrumentalSelectionRegression:
+    """Regression tests for instrumental selection bug.
+
+    Bug: User selected 'with_backing' instrumental in the UI but the final
+    video used the clean instrumental instead.
+
+    Root cause: The GCE worker's find_file() always prioritized
+    '*instrumental_clean*' patterns before generic patterns, ignoring
+    the user's selection.
+    """
+
+    def test_bug_scenario_both_instrumentals_present(self, tmp_path):
+        """Recreate the exact bug scenario where both instrumentals exist.
+
+        This is the key regression test. When both instrumentals are downloaded
+        from GCS (which happens with the GCE worker), the correct one must
+        be selected based on the user's choice.
+        """
+        # Setup: Both instrumentals in stems/ (as downloaded from GCS)
+        stems = tmp_path / "stems"
+        stems.mkdir()
+
+        (stems / "instrumental_clean.flac").touch()
+        (stems / "instrumental_with_backing.flac").touch()
+
+        # Also have properly named versions in the root (from _setup_working_directory)
+        (tmp_path / "Artist - Song (Instrumental Clean).flac").touch()
+        (tmp_path / "Artist - Song (Instrumental Backing).flac").touch()
+
+        # When user selected 'with_backing', the backing version MUST be found
+        backing_patterns = (
+            "*instrumental_with_backing*.flac", "*Instrumental Backing*.flac",
+            "*with_backing*.flac", "*Backing*.flac",
+            "*instrumental*.flac", "*Instrumental*.flac",
+            "*instrumental*.wav"
+        )
+        result = find_file(tmp_path, *backing_patterns)
+
+        assert result is not None
+        # Must find a backing-related file, not the clean one
+        name = result.name.lower()
+        assert "backing" in name or "with_backing" in name, \
+            f"Expected backing instrumental but found: {result.name}"
+
+    def test_clean_selection_still_works(self, tmp_path):
+        """Verify clean selection still works correctly after the fix."""
+        stems = tmp_path / "stems"
+        stems.mkdir()
+
+        (stems / "instrumental_clean.flac").touch()
+        (stems / "instrumental_with_backing.flac").touch()
+
+        (tmp_path / "Artist - Song (Instrumental Clean).flac").touch()
+        (tmp_path / "Artist - Song (Instrumental Backing).flac").touch()
+
+        # When user selected 'clean', the clean version must be found
+        clean_patterns = (
+            "*instrumental_clean*.flac", "*Instrumental Clean*.flac",
+            "*instrumental*.flac", "*Instrumental*.flac",
+            "*instrumental*.wav"
+        )
+        result = find_file(tmp_path, *clean_patterns)
+
+        assert result is not None
+        name = result.name.lower()
+        assert "clean" in name, f"Expected clean instrumental but found: {result.name}"

backend/tests/test_impersonation.py

@@ -11,6 +11,7 @@ from fastapi import FastAPI
 from backend.api.routes.admin import router
 from backend.api.dependencies import require_admin
 from backend.services.user_service import get_user_service
+from backend.services.auth_service import AuthResult, UserType
 from backend.models.user import User, Session
 
 
@@ -20,15 +21,29 @@ app.include_router(router, prefix="/api")
 
 
 def get_mock_admin():
-    """Override for require_admin dependency - returns admin user."""
-    return ("admin@nomadkaraoke.com", "admin", 1)
+    """Override for require_admin dependency - returns admin AuthResult."""
+    return AuthResult(
+        is_valid=True,
+        user_type=UserType.ADMIN,
+        remaining_uses=-1,
+        message="Admin session valid",
+        user_email="admin@nomadkaraoke.com",
+        is_admin=True,
+    )
 
 
 def get_mock_regular_user():
     """Override for require_admin dependency - returns regular user (should fail)."""
     # This simulates what happens when a non-admin tries to access
     # In reality, require_admin raises 403, but we test the logic
-    return ("user@example.com", "user", 0)
+    return AuthResult(
+        is_valid=True,
+        user_type=UserType.LIMITED,
+        remaining_uses=5,
+        message="User session valid",
+        user_email="user@example.com",
+        is_admin=False,
+    )
 
 
 @pytest.fixture