Files
karaoke-gen/backend/tests/test_admin_delete_outputs.py
T
Andrew Beveridge ☄️andClaude Opus 5.5 bfc8f7fb0f feat(cdg): configurable title card + per-theme CDG lyrics font (Vocal Star up card) (v0.273.0) (#1157)
## Summary
Vocal Star (and other commercial producers) need CDG files in their own
house style. Matt's 2025-02-20 email showed our CDG up card overflowing
its bordered design. He asked for his simpler card instead: logo on top,
then title, a small "MADE FAMOUS BY" line, then the artist.

Two pipeline limits blocked that:
- the CDG title card was hardcoded;
- a theme could only have **one font** for everything. The shared `font`
asset (`intro.font`) overwrites `karaoke.font_path` and `cdg.font_path`
at render time.

## Changes
- **Title card (cdgmaker composer):** new optional keys; all defaults
reproduce today's output.
- `title_separator_text` / `_color` / `_font_size`: a line between title
and artist.
  - `title_font_size`, `artist_font_size`, `title_max_height`.
- `title_block_top`: centre the block below a logo baked into the
background.
- It shrinks the title first, then the artist, so it can't loop forever.
- **Outro:** respects `title_block_top` and shrinks long text. Before,
an `assert` crashed when the text was taller than 200px.
- **Fonts:**
- The CDG title card and outro use the theme's main font
(`cdg.title_font_path`, fed by the shared `font` asset).
- A theme may keep a **distinct CDG lyrics font** via a new `cdg_font`
asset. The theme service emits it only when it differs from
`intro.font`, and `update_asset_paths` applies the shared font first so
section overrides win.
  - No visible change for existing themes, which all use one font.
- **Tenant theme editor:** keeps a distinct, available CDG font on save,
and copies it into the theme's assets if it's bundled.
- Docs: API.md.

## Testing
- New `tests/unit/lyrics_transcriber/output/test_cdg_title_card.py`
renders **real CDG files**, decodes the packets back into frames and
checks:
  - the separator sits between title and artist;
  - text stays below `title_block_top` and inside the safe area;
  - the title font is applied, and a missing one falls back;
  - long outro text shrinks instead of crashing.
- New tests for asset-mapping order, `cdg_font` emission, theme-editor
font handling, and the updated mapping assertion.
- Package unit tests: 2053 passed. Backend: 6056 passed (emulator tests
excluded locally).
- Local CodeRabbit with `--fresh`: no findings.
- Rendered Vocal Star samples (short, wrapped-long and very long
title/artist), decoded and visually checked against Matt's design.

After deploy, the Vocal Star theme gets: a new up-card background (logo
cropped from Matt's own card), separator "MADE FAMOUS BY",
`title_block_top`, black border, Avenir as the main font and Oswald kept
for CDG lyrics.

@coderabbitai ignore

🤖 Generated with [Claude Code](https://claude.com/claude-code)

https://claude.ai/code/session_01Gp5fBmsmWJxgkEHb4JfhXR

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-15 00:58:42 -04:00

612 lines
27 KiB
Python

"""
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_removes_nomad_gcs_master(self, client, mock_complete_job):
"""Deleting a NOMAD job's outputs must also remove its 720p master from the
GCS fast-sync mirror (wiring guard for the delete side)."""
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.services.nomad_master_mirror.cleanup_nomad_masters') as mock_cleanup:
mock_jm = Mock()
mock_jm.get_job.return_value = mock_complete_job # brand_code = "NOMAD-1234"
mock_jm_class.return_value = mock_jm
mock_db = Mock()
mock_db.collection.return_value.document.return_value = Mock()
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_cleanup.assert_called_once_with("NOMAD-1234")
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
class TestDeleteOutputsGCSFinals:
"""Tests for GCS finals folder deletion."""
def test_delete_outputs_deletes_gcs_finals(self, client, mock_complete_job):
"""Test that GCS finals folder is deleted when outputs are deleted."""
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.services.storage_service.StorageService') as mock_storage_class:
mock_jm = Mock()
mock_jm.get_job.return_value = mock_complete_job
mock_jm_class.return_value = mock_jm
# Mock storage service
mock_storage = Mock()
mock_storage.delete_folder.return_value = 4 # 4 files deleted
mock_storage_class.return_value = mock_storage
# 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()
# Verify GCS finals was deleted
mock_storage.delete_folder.assert_called_once_with("jobs/test-job-123/finals/")
assert "gcs_finals" in data["deleted_services"]
assert data["deleted_services"]["gcs_finals"]["status"] == "success"
assert data["deleted_services"]["gcs_finals"]["deleted_count"] == 4
assert data["deleted_services"]["gcs_finals"]["path"] == "jobs/test-job-123/finals/"
def test_delete_outputs_gcs_success_with_zero_files(self, client, mock_complete_job):
"""Test that GCS deletion reports success even when no files exist."""
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.services.storage_service.StorageService') as mock_storage_class:
mock_jm = Mock()
mock_jm.get_job.return_value = mock_complete_job
mock_jm_class.return_value = mock_jm
# Mock storage service - no files to delete
mock_storage = Mock()
mock_storage.delete_folder.return_value = 0
mock_storage_class.return_value = mock_storage
# 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()
# Still success even with zero files deleted
assert data["deleted_services"]["gcs_finals"]["status"] == "success"
assert data["deleted_services"]["gcs_finals"]["deleted_count"] == 0
def test_delete_outputs_continues_if_gcs_fails(self, client, mock_complete_job):
"""Test that other deletions continue even if GCS deletion fails."""
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.services.storage_service.StorageService') as mock_storage_class:
mock_jm = Mock()
mock_jm.get_job.return_value = mock_complete_job
mock_jm_class.return_value = mock_jm
# Mock storage service to fail
mock_storage = Mock()
mock_storage.delete_folder.side_effect = Exception("GCS error")
mock_storage_class.return_value = mock_storage
# 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")
# Should still succeed (partial success) with error for GCS
assert response.status_code == 200
data = response.json()
assert "gcs_finals" in data["deleted_services"]
assert data["deleted_services"]["gcs_finals"]["status"] == "error"
assert "GCS error" in data["deleted_services"]["gcs_finals"]["error"]
def test_delete_outputs_gcs_uses_correct_path(self, client, mock_complete_job):
"""Test that GCS deletion uses the correct path format."""
mock_complete_job.job_id = "abc-123-xyz"
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.services.storage_service.StorageService') as mock_storage_class:
mock_jm = Mock()
mock_jm.get_job.return_value = mock_complete_job
mock_jm_class.return_value = mock_jm
mock_storage = Mock()
mock_storage.delete_folder.return_value = 2
mock_storage_class.return_value = mock_storage
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/abc-123-xyz/delete-outputs")
assert response.status_code == 200
# Verify path format is jobs/{job_id}/finals/
mock_storage.delete_folder.assert_called_once_with("jobs/abc-123-xyz/finals/")
class TestDeleteOutputsBrandCodeRecycling:
"""Tests for brand code recycling during output deletion."""
def test_brand_code_recycled_on_success(self, client, mock_complete_job):
"""Test that brand code is recycled when Dropbox and GDrive cleanup succeed."""
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.services.brand_code_service.BrandCodeService.parse_brand_code') as mock_parse, \
patch('backend.services.brand_code_service.get_brand_code_service') as mock_get_svc:
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
mock_parse.return_value = ("NOMAD", 1234)
mock_svc = Mock()
mock_get_svc.return_value = mock_svc
response = client.post("/api/admin/jobs/test-job-123/delete-outputs")
assert response.status_code == 200
data = response.json()
# Brand code should be recycled (all services skip = success condition)
assert "brand_code" in data["deleted_services"]
assert data["deleted_services"]["brand_code"]["status"] == "recycled"
assert data["deleted_services"]["brand_code"]["code"] == "NOMAD-1234"
mock_svc.recycle_brand_code.assert_called_once_with("NOMAD", 1234)
def test_tenant_preserved_brand_code_is_never_recycled(self, client, mock_complete_job):
"""A tenant's own track code (keep_brand_code) must not go back into a counter."""
mock_complete_job.keep_brand_code = "NOMAD-1234" # looks allocated, but tenant-supplied
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.services.brand_code_service.get_brand_code_service') as mock_get_svc:
mock_jm = Mock()
mock_jm.get_job.return_value = mock_complete_job
mock_jm_class.return_value = mock_jm
mock_user_service.return_value.db = Mock()
response = client.post("/api/admin/jobs/test-job-123/delete-outputs")
assert response.status_code == 200
assert response.json()["deleted_services"]["brand_code"]["reason"] == "Tenant-supplied code (not allocated)"
mock_get_svc.return_value.recycle_brand_code.assert_not_called()
def test_brand_code_not_recycled_without_brand_code(self, client, mock_job_no_outputs):
"""Test that no recycling happens when job has no brand code."""
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_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()
# No brand_code key in response since there's nothing to recycle
assert "brand_code" not in data["deleted_services"]
def test_brand_code_skipped_when_dropbox_fails(self, client, mock_complete_job):
"""Test that brand code is NOT recycled when Dropbox cleanup fails."""
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.services.dropbox_service.get_dropbox_service') as mock_dropbox_svc:
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
# Make Dropbox fail
mock_dropbox = Mock()
mock_dropbox.is_configured = True
mock_dropbox.delete_folder.side_effect = Exception("Dropbox error")
mock_dropbox_svc.return_value = mock_dropbox
response = client.post("/api/admin/jobs/test-job-123/delete-outputs")
assert response.status_code == 200
data = response.json()
assert data["deleted_services"]["brand_code"]["status"] == "skipped"
assert "incomplete" in data["deleted_services"]["brand_code"]["reason"].lower()
def test_brand_code_recycle_error_handled_gracefully(self, client, mock_complete_job):
"""Test that brand code recycling errors don't crash the endpoint."""
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.services.brand_code_service.BrandCodeService.parse_brand_code') as mock_parse:
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
# Make parse_brand_code raise an error
mock_parse.side_effect = ValueError("Invalid brand code format")
response = client.post("/api/admin/jobs/test-job-123/delete-outputs")
assert response.status_code == 200
data = response.json()
assert data["deleted_services"]["brand_code"]["status"] == "failed"
assert "Invalid brand code format" in data["deleted_services"]["brand_code"]["error"]