Files
karaoke-gen/backend/tests/test_theme_rerender.py
Andrew Beveridge ☄️andClaude Opus 5.5 ad64286004 feat(tenant): tenant portals are shared workspaces (v0.297.0) (#1266)
## Summary
Andrew's expectation: "all jobs in the tenant portal are accessible to
everyone who has permission to access that portal." Until now a
non-admin only saw/opened jobs whose `user_email` was their own, even on
a tenant portal. A client logging in with their own email never saw the
10 jobs bulk-uploaded for them under a separate `@nomadkaraoke.com`
address, and re-submitted every song.

## Rule (`backend/services/job_access.py`)
- Admins: every job.
- Owner: their jobs.
- **Tenant portal member** (currently allowed to sign in:
`allowed_emails` / `allowed_email_domains`, tenant active): every job of
that tenant. Re-checked per request against the live tenant config (~5
min cache), so removing someone from the allowlist removes access. Fails
closed on lookup errors.
- Consumer jobs (no tenant): owner-only, unchanged.

## Wired into
- `_check_job_ownership` (all job routes: view, edit, rerender, delete,
…)
- full-auth review access (`require_review_auth`:
lyrics/instrumental/audio-edit)
- file-upload guards (finalize, style uploads; style uploads keep
denying ownerless legacy jobs as before)
- `GET /api/jobs`: members on a tenant portal list all of that tenant's
jobs (still tenant-scoped)
- tenant theme refresh/outdated/rerender-outdated scope now covers the
whole portal (routes were already member-gated)

Unchanged on purpose: kjbox singer review links and the consumer
visibility toggle (consumer-only).

## Testing
- New `backend/tests/test_tenant_shared_jobs.py` (20): member/domain
member/case, outsider, consumer privacy, cross-tenant, inactive tenant,
no allowlist, removed member, fail-closed, token-without-email,
ownerless per-route, list scoping (member/outsider/consumer portal),
review auth 200/403, ownership wrapper.
- Updated theme tests that asserted the old owner-only scope; added
teammate-can-rerender.
- Local: 2,710 job/review/upload/tenant tests + 656 theme/tenant tests
pass (only `test_emulator_integration.py` fails locally, which needs the
Firestore emulator; same on main).
- Local CodeRabbit: 1 finding (ownerless legacy jobs on style uploads)
fixed; re-review clean.

## Prod cleanup done alongside (admin API)
Deleted (archived) the 10 stale Sept bulk-upload jobs for the randy-vild
tenant that duplicated his completed RVILD tracks.

@coderabbitai ignore

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

https://claude.ai/code/session_012RYLVVUdF2J1bNeVa2uLXA

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-11 14:49:27 -05:00

394 lines
18 KiB
Python

"""
Tests for re-rendering a finished tenant track with the tenant's current theme.
Covers validation, the service (theme re-snapshot, atomic claim, artifact
cleanup, screens-worker trigger + rollback), the POST /api/jobs/{id}/rerender
route (ownership, tenant allowlist), and the encoding-worker id keying that
stops a re-run from getting the previous run's cached render/encode back.
"""
from types import SimpleNamespace
from unittest.mock import AsyncMock, MagicMock, patch
import pytest
from fastapi.testclient import TestClient
from google.cloud.firestore_v1 import DELETE_FIELD
from backend.services.theme_rerender_service import (
RerenderConflictError,
RerenderError,
ThemeRerenderService,
validate_rerender,
)
from backend.workers.supersede import encoding_worker_job_id
def _job(**overrides):
fields = dict(
job_id="job123",
status="complete",
tenant_id="randy-vild",
user_email="randy@example.com",
theme_id="randy-vild",
color_overrides={},
outputs_deleted_at=None,
prep_only=False,
finalise_only=False,
state_data={"instrumental_selection": "custom"},
file_urls={"lyrics": {"corrections": "jobs/job123/lyrics/corrections.json"}},
)
fields.update(overrides)
return SimpleNamespace(**fields)
class TestValidateRerender:
def test_valid_tenant_job(self):
assert validate_rerender(_job()) is None
@pytest.mark.parametrize("overrides, fragment", [
({"tenant_id": None}, "portal tracks"),
({"status": "rendering_video"}, "Only finished tracks"),
({"outputs_deleted_at": "2026-09-29T18:47:13Z"}, "outputs were deleted"),
({"theme_id": None}, "wasn't made from a theme"),
({"prep_only": True}, "can't be re-rendered"),
({"state_data": {}}, "instrumental selection"),
({"file_urls": {}}, "reviewed lyrics"),
({"state_data": {"instrumental_selection": "clean", "dropbox_link": "https://db"}}, "Dropbox folder"),
({"state_data": {"instrumental_selection": "clean", "youtube_url": "https://yt"}}, "published"),
({"state_data": {"instrumental_selection": "clean", "gdrive_files": {"mp4": "x"}}}, "published"),
])
def test_rejections(self, overrides, fragment):
assert fragment in validate_rerender(_job(**overrides))
def _service(claim_status="complete", trigger_ok=True):
"""ThemeRerenderService wired to a fake Firestore transaction + storage."""
job_manager = MagicMock()
doc_ref = MagicMock()
snapshot = MagicMock(exists=True)
snapshot.to_dict.return_value = {"status": claim_status}
doc_ref.get.return_value = snapshot
job_manager.firestore.db.collection.return_value.document.return_value = doc_ref
storage = MagicMock()
worker_service = MagicMock()
worker_service.trigger_screens_worker = AsyncMock(return_value=trigger_ok)
return ThemeRerenderService(job_manager=job_manager, storage=storage), doc_ref, storage, worker_service
def _passthrough_transactional(fn):
return fn
@pytest.fixture
def patched_deps():
prepare = MagicMock(return_value=(
"jobs/job123/style/style_params.json",
{"karaoke_background": "themes/randy-vild/assets/bg-new.jpg"},
None,
))
with patch("backend.api.routes.file_upload._prepare_theme_for_job", prepare), \
patch("backend.services.theme_rerender_service.firestore.transactional", _passthrough_transactional):
yield prepare
class TestThemeRerenderService:
@pytest.mark.asyncio
async def test_resnapshots_theme_claims_and_triggers_screens(self, patched_deps):
service, doc_ref, storage, worker_service = _service()
transaction = service.job_manager.firestore.db.transaction.return_value
with patch("backend.services.worker_service.get_worker_service", return_value=worker_service):
await service.start(_job(), theme_id="randy-vild", requested_by="randy@example.com")
patched_deps.assert_called_once_with("job123", "randy-vild", None)
transaction.update.assert_called_once()
update = transaction.update.call_args.args[1]
assert update["status"] == "lyrics_complete"
assert update["state_data.regen_restore_status"] == "review_complete"
assert update["style_params_gcs_path"] == "jobs/job123/style/style_params.json"
assert update["style_assets"] == {"karaoke_background": "themes/randy-vild/assets/bg-new.jpg"}
assert update["theme_id"] == "randy-vild"
for key in ("screens_progress", "render_progress", "video_progress", "encoding_progress"):
assert update[f"state_data.{key}"] is DELETE_FIELD
assert update["file_urls.screens"] is DELETE_FIELD
assert update["file_urls.videos.with_vocals"] is DELETE_FIELD
deleted = {c.args[0] for c in storage.delete_file.call_args_list}
assert "jobs/job123/screens/title.mov" in deleted
assert "jobs/job123/screens/end.png" in deleted
assert "jobs/job123/videos/with_vocals.mkv" in deleted
assert all(c.kwargs.get("ignore_missing") for c in storage.delete_file.call_args_list)
worker_service.trigger_screens_worker.assert_awaited_once_with("job123")
@pytest.mark.asyncio
async def test_passes_color_overrides(self, patched_deps):
service, _, _, worker_service = _service()
with patch("backend.services.worker_service.get_worker_service", return_value=worker_service):
await service.start(_job(color_overrides={"sung": "#fff"}), theme_id="t", requested_by="x")
patched_deps.assert_called_once_with("job123", "t", {"sung": "#fff"})
@pytest.mark.asyncio
async def test_conflict_when_job_no_longer_complete(self, patched_deps):
"""A double-click: the second claim sees the job already re-rendering."""
service, _, storage, worker_service = _service(claim_status="lyrics_complete")
transaction = service.job_manager.firestore.db.transaction.return_value
with patch("backend.services.worker_service.get_worker_service", return_value=worker_service):
with pytest.raises(RerenderConflictError):
await service.start(_job(), theme_id="randy-vild", requested_by="x")
transaction.update.assert_not_called()
storage.delete_file.assert_not_called()
worker_service.trigger_screens_worker.assert_not_awaited()
@pytest.mark.asyncio
async def test_restores_complete_when_trigger_fails(self, patched_deps):
service, _, _, worker_service = _service(trigger_ok=False)
with patch("backend.services.worker_service.get_worker_service", return_value=worker_service):
with pytest.raises(RerenderError) as exc:
await service.start(_job(), theme_id="randy-vild", requested_by="x")
assert exc.value.status_code == 503
restore = service.job_manager.update_job.call_args.args[1]
assert restore["status"] == "complete"
assert restore["state_data.regen_restore_status"] is DELETE_FIELD
@pytest.mark.asyncio
async def test_invalid_job_rejected_before_any_work(self, patched_deps):
service, _, storage, _ = _service()
with pytest.raises(RerenderError):
await service.start(_job(tenant_id=None), theme_id="t", requested_by="x")
patched_deps.assert_not_called()
storage.delete_file.assert_not_called()
class TestRerenderReviewFixes:
@pytest.mark.asyncio
async def test_deletes_old_title_end_movs_from_finals(self, patched_deps):
"""The encoder globs **/*Title*.mov — an old finals MOV would be spliced in."""
service, _, storage, worker_service = _service()
storage.list_files.return_value = [
"jobs/job123/finals/Randy Vild - What Goes Up (Title).mov",
"jobs/job123/finals/Randy Vild - What Goes Up (End).mov",
"jobs/job123/finals/title_mov.mov",
"jobs/job123/finals/end_mov.mov",
"jobs/job123/finals/lossy_4k_mp4.mp4",
"jobs/job123/finals/lossless_4k_mkv.mkv",
]
with patch("backend.services.worker_service.get_worker_service", return_value=worker_service):
await service.start(_job(), theme_id="randy-vild", requested_by="x")
storage.list_files.assert_called_once_with("jobs/job123/finals/")
deleted = {c.args[0] for c in storage.delete_file.call_args_list}
assert "jobs/job123/finals/Randy Vild - What Goes Up (Title).mov" in deleted
assert "jobs/job123/finals/Randy Vild - What Goes Up (End).mov" in deleted
assert "jobs/job123/finals/title_mov.mov" in deleted
assert "jobs/job123/finals/end_mov.mov" in deleted
assert "jobs/job123/finals/lossy_4k_mp4.mp4" not in deleted
assert "jobs/job123/finals/lossless_4k_mkv.mkv" not in deleted
def test_failed_rerender_is_rerenderable(self):
job = _job(status="failed", state_data={"instrumental_selection": "custom",
"theme_rerender": {"theme_id": "randy-vild"}})
assert validate_rerender(job) is None
def test_failed_ordinary_job_is_not_rerenderable(self):
assert "Only finished tracks" in validate_rerender(_job(status="failed"))
@pytest.mark.asyncio
async def test_claims_failed_rerender(self, patched_deps):
service, _, _, worker_service = _service(claim_status="failed")
transaction = service.job_manager.firestore.db.transaction.return_value
job = _job(status="failed", state_data={"instrumental_selection": "custom",
"theme_rerender": {"theme_id": "randy-vild"}})
with patch("backend.services.worker_service.get_worker_service", return_value=worker_service):
await service.start(job, theme_id="randy-vild", requested_by="x")
transaction.update.assert_called_once()
assert transaction.update.call_args.args[1]["error_message"] is None
worker_service.trigger_screens_worker.assert_awaited_once_with("job123")
class TestDropboxArchivedTenantJobs:
"""Tenants like randy-vild archive to Dropbox (RVILD-0001 - Artist - Title)."""
def test_dropbox_archived_job_with_brand_code_is_rerenderable(self):
job = _job(state_data={"instrumental_selection": "custom",
"dropbox_link": "https://db", "brand_code": "RVILD-0001"})
assert validate_rerender(job) is None
@pytest.mark.asyncio
async def test_marker_records_brand_code_to_reuse(self, patched_deps):
service, _, _, worker_service = _service()
transaction = service.job_manager.firestore.db.transaction.return_value
job = _job(state_data={"instrumental_selection": "custom",
"dropbox_link": "https://db", "brand_code": "RVILD-0001"})
with patch("backend.services.worker_service.get_worker_service", return_value=worker_service):
await service.start(job, theme_id="randy-vild", requested_by="x")
marker = transaction.update.call_args.args[1]["state_data.theme_rerender"]
assert marker["brand_code"] == "RVILD-0001"
def test_rerender_brand_code(self):
from backend.services.theme_rerender_service import rerender_brand_code
assert rerender_brand_code(_job(state_data={"theme_rerender": {"brand_code": "RVILD-0001"}})) == "RVILD-0001"
assert rerender_brand_code(_job(state_data={"brand_code": "RVILD-0001"})) is None
assert rerender_brand_code(_job(state_data=None)) is None
def test_orchestrator_keeps_brand_code_during_rerender(self):
"""Refresh the existing Dropbox folder instead of allocating RVILD-0002."""
from backend.workers.video_worker_orchestrator import create_orchestrator_config_from_job
job = MagicMock()
job.job_id = "job123"
job.artist = "A"
job.title = "T"
job.keep_brand_code = None
job.state_data = {"instrumental_selection": "custom", "brand_code": "RVILD-0001",
"theme_rerender": {"brand_code": "RVILD-0001"}}
job.file_urls = {}
config = create_orchestrator_config_from_job(job, temp_dir="/tmp/x")
assert config.keep_brand_code == "RVILD-0001"
class TestEncodingWorkerJobId:
def test_generation_zero_keeps_plain_job_id(self):
assert encoding_worker_job_id("job123", 0) == "job123"
def test_generation_suffixes_job_id(self):
assert encoding_worker_job_id("job123", 3) == "job123_g3"
def test_orchestrator_config_captures_generation(self):
from backend.workers.video_worker_orchestrator import create_orchestrator_config_from_job
job = MagicMock()
job.job_id = "job123"
job.artist = "A"
job.title = "T"
job.state_data = {"worker_generation": 4, "instrumental_selection": "clean"}
job.file_urls = {}
config = create_orchestrator_config_from_job(job, temp_dir="/tmp/x")
assert config.worker_generation == 4
# --- Route ---------------------------------------------------------------
@pytest.fixture
def client():
from backend.main import app
yield TestClient(app), app
app.dependency_overrides.clear()
def _auth(email="randy@example.com", is_admin=False):
from backend.services.auth_service import AuthResult, UserType
return AuthResult(
is_valid=True,
user_type=UserType.ADMIN if is_admin else UserType.UNLIMITED,
remaining_uses=-1,
message="Valid",
user_email=email,
is_admin=is_admin,
)
def _call(client, auth, job, tenant, start=None):
test_client, app = client
from backend.api.dependencies import require_auth
async def override():
return auth
app.dependency_overrides[require_auth] = override
job_manager = MagicMock()
job_manager.get_job.return_value = job
tenant_service = MagicMock()
tenant_service.get_tenant_config.return_value = tenant
start = start or AsyncMock()
with patch("backend.api.routes.jobs.JobManager", return_value=job_manager), \
patch("backend.services.tenant_service.get_tenant_service", return_value=tenant_service), \
patch.object(ThemeRerenderService, "start", start):
return test_client.post(f"/api/jobs/{job.job_id}/rerender"), start
def _tenant(allowed=True, active=True):
tenant = MagicMock()
tenant.is_active = active
tenant.is_email_allowed.return_value = allowed
tenant.defaults.locked_theme = "randy-vild"
tenant.defaults.theme_id = None
tenant.id = "randy-vild"
return tenant
class TestRerenderRoute:
def test_owner_starts_rerender_with_tenant_theme(self, client):
job = _job()
resp, start = _call(client, _auth(), job, _tenant())
assert resp.status_code == 200, resp.text
assert resp.json()["theme_id"] == "randy-vild"
start.assert_awaited_once()
assert start.await_args.kwargs["theme_id"] == "randy-vild"
assert start.await_args.kwargs["requested_by"] == "randy@example.com"
def test_non_member_forbidden(self, client):
tenant = _tenant()
tenant.is_email_allowed.side_effect = lambda e: e == "randy@example.com"
resp, start = _call(client, _auth(email="someone@else.com"), _job(), tenant)
assert resp.status_code == 403
start.assert_not_awaited()
def test_teammate_on_allowlist_allowed(self, client):
"""Tenant portals are shared: another member may re-render a teammate's track."""
resp, start = _call(client, _auth(email="colleague@randy.com"), _job(), _tenant())
assert resp.status_code == 200
start.assert_awaited_once()
def test_owner_removed_from_allowlist_forbidden(self, client):
resp, start = _call(client, _auth(), _job(), _tenant(allowed=False))
assert resp.status_code == 403
start.assert_not_awaited()
def test_admin_allowed_on_any_job(self, client):
resp, start = _call(client, _auth(email="admin@nomadkaraoke.com", is_admin=True), _job(), _tenant(allowed=False))
assert resp.status_code == 200
start.assert_awaited_once()
def test_consumer_job_rejected(self, client):
resp, start = _call(client, _auth(), _job(tenant_id=None), _tenant())
assert resp.status_code == 400
start.assert_not_awaited()
def test_inactive_tenant_rejected(self, client):
resp, start = _call(client, _auth(), _job(), _tenant(active=False))
assert resp.status_code == 400
start.assert_not_awaited()
def test_conflict_maps_to_409(self, client):
start = AsyncMock(side_effect=RerenderConflictError("already"))
resp, _ = _call(client, _auth(), _job(), _tenant(), start=start)
assert resp.status_code == 409
class TestRetryAfterFailedRerender:
def test_retry_reruns_rerender_when_screens_missing(self, client):
test_client, app = client
from backend.api.dependencies import require_auth
async def override():
return _auth()
app.dependency_overrides[require_auth] = override
job = _job(status="failed", state_data={"instrumental_selection": "custom",
"theme_rerender": {"theme_id": "randy-vild"}})
job.error_details = {"stage": "screens"}
job_manager = MagicMock()
job_manager.get_job.return_value = job
start = AsyncMock()
with patch("backend.api.routes.jobs.job_manager", job_manager), \
patch("backend.api.routes.jobs.JobManager", return_value=job_manager), \
patch.object(ThemeRerenderService, "start", start):
resp = test_client.post("/api/jobs/job123/retry")
assert resp.status_code == 200, resp.text
assert resp.json()["retry_stage"] == "theme_rerender"
assert start.await_args.kwargs["theme_id"] == "randy-vild"