"""Vídeo de revisão × vídeo final (doc/clipador/REVISAO.md, pedido do dono 18/11/2026): "quando o clipe está ali para a gente aprovar, a legenda é só de dev. Quando a gente aprovar, ele vai renderizar o vídeo de novo, removendo as coisas de dev". O render da fila é o de revisão (dev=True); aprovar enfileira o final (dev=False); publicar só usa o final.""" import json import sqlite3 from pathlib import Path import app.db as db_module import app.editor_api as editor_api import app.worker as worker_module from app import layout from app.db import Database from .test_sources_and_api import auth, env, seed_session # noqa: F401 - fixture reaproveitada def add_ready_clip(engine, sid, cid=1, layers: list[str] | None = None, status="ready"): engine.db.run( "INSERT INTO clips (id, session_id, peak_s, start_s, end_s, score, source, status, title, file, thumb, review_dev_json," " created_at, updated_at) VALUES (?, ?, 100, 90, 160, 8, 'chat', ?, 't', ?, ?, ?, 'x', 'x')", cid, sid, status, f"output/clipper/{sid}/clip-{cid}.mp4", f"output/clipper/{sid}/clip-{cid}.jpg", None if layers is None else json.dumps(layers)) class RenderSpy: """Troca o render de verdade: guarda com que `dev` e para qual arquivo cada render foi pedido.""" def __init__(self, monkeypatch, engine, fail: bool = False): self.calls: list[dict] = [] self.fail = fail monkeypatch.setattr(worker_module, "REPO_ROOT", engine.settings.data_dir.parent) # caminhos relativos do teste monkeypatch.setattr(editor_api, "ensure_edit", lambda eng, clip, session: {"project": {}}) monkeypatch.setattr(editor_api, "render_clip_edit", self) def __call__(self, engine, clip, session, edit, out: Path, thumb: Path, dev: bool = True): self.calls.append({"clip": clip["id"], "out": out.name, "thumb": thumb.name, "dev": dev}) if self.fail: from app import media raise media.MediaError("ffmpeg caiu") return f"output/clipper/{clip['session_id']}/{out.stem}-cover.jpg" def view(client, cid=1) -> dict: return client.get(f"/v1/clips/{cid}", headers=auth()).json() def approve(client, cid=1, status="approved") -> dict: r = client.patch(f"/v1/clips/{cid}", json={"status": status}, headers=auth()) assert r.status_code == 200, r.text return r.json() # ---------------------------------------------------------------- aprovar → final com dev=False def test_approve_queues_final_render_without_dev_layers(env, monkeypatch): # noqa: F811 client, engine = env sid = seed_session(engine) add_ready_clip(engine, sid, layers=["translation"]) spy = RenderSpy(monkeypatch, engine) before = view(client) assert before["review"]["devLayers"] == ["translation"] and before["final"] is None and before["publishFile"] is None body = approve(client) assert body["status"] == "approved" assert body["final"]["status"] == "pending" and body["publishFile"] is None # nada publicável ainda assert engine.wake_clips.is_set() engine.render_pending() assert spy.calls == [{"clip": 1, "out": "clip-1-final.mp4", "thumb": "clip-1-final.jpg", "dev": False}] after = view(client) final = after["final"] assert final["status"] == "ready" and not final["reused"] and final["error"] is None assert final["file"].endswith("clip-1-final.mp4") and final["thumb"].endswith("clip-1-final.jpg") assert final["cover"].endswith("clip-1-final-cover.jpg") assert after["publishFile"] == final["file"] != after["file"] # o de revisão continua sendo `file` engine.render_pending() assert len(spy.calls) == 1 # pronto não renderiza de novo def test_review_render_of_the_queue_stays_dev_true(env, monkeypatch): # noqa: F811 client, engine = env monkeypatch.setattr(worker_module, "REPO_ROOT", engine.settings.data_dir.parent) sid = seed_session(engine) add_ready_clip(engine, sid, layers=None, status="pending") spy = RenderSpy(monkeypatch, engine) engine.render_pending() assert spy.calls == [{"clip": 1, "out": "clip-1.mp4", "thumb": "clip-1.jpg", "dev": True}] assert view(client)["status"] == "ready" and view(client)["final"] is None def test_unknown_layers_render_final(env, monkeypatch): # noqa: F811 """Sem saber o que entrou no vídeo de revisão (`review_dev_json` NULL), o final é renderizado por cautela.""" client, engine = env sid = seed_session(engine) add_ready_clip(engine, sid, layers=None) spy = RenderSpy(monkeypatch, engine) assert approve(client)["final"]["status"] == "pending" engine.render_pending() assert [c["dev"] for c in spy.calls] == [False] # ---------------------------------------------------------------- sem camadas dev: reaproveita def test_without_dev_layers_review_is_already_final(env, monkeypatch): # noqa: F811 client, engine = env sid = seed_session(engine) add_ready_clip(engine, sid, layers=[]) engine.db.run("INSERT INTO edits (clip_id, project_json, created_at, updated_at, cover) VALUES (1, '{}', 'x', 'x', ?)", f"output/clipper/{sid}/clip-1-cover.jpg") spy = RenderSpy(monkeypatch, engine) body = approve(client) assert body["final"]["status"] == "ready" and body["final"]["reused"] assert body["publishFile"] == body["file"] and body["final"]["cover"].endswith("clip-1-cover.jpg") engine.render_pending() assert spy.calls == [] # não renderizou de novo # ---------------------------------------------------------------- publicação nunca pega o de revisão def test_publish_file_is_never_the_review_video(env, monkeypatch): # noqa: F811 client, engine = env sid = seed_session(engine) add_ready_clip(engine, sid, 1, layers=["translation"]) add_ready_clip(engine, sid, 2, layers=["dub", "translation"]) spy = RenderSpy(monkeypatch, engine, fail=True) def publishable() -> dict[int, str | None]: clips = client.get("/v1/clips?status=ready,approved,published", headers=auth()).json()["clips"] return {c["id"]: c["publishFile"] for c in clips} assert publishable() == {1: None, 2: None} # pronto para aprovar = só revisão approve(client, 1) approve(client, 2, status="published") # marcado publicado direto também pede o final assert publishable() == {1: None, 2: None} # final na fila engine.render_pending() # o render final falha for cid in (1, 2): v = view(client, cid) assert v["final"]["status"] == "error" and "ffmpeg caiu" in v["final"]["error"] assert v["publishFile"] is None and v["status"] in ("approved", "published") # erro não vira revisão publicável # "Tentar de novo" (POST /final): volta à fila e, desta vez, sai. spy.fail = False assert client.post("/v1/clips/1/final", headers=auth()).json()["final"]["status"] == "pending" engine.render_pending() v = view(client, 1) assert v["publishFile"] and v["publishFile"] != v["file"] and v["publishFile"].endswith("-final.mp4") assert all(f is None or f.endswith("-final.mp4") for f in publishable().values()) # Só corte aprovado tem final. client.patch("/v1/clips/2", json={"status": "ready"}, headers=auth()) assert client.post("/v1/clips/2/final", headers=auth()).status_code == 409 # ---------------------------------------------------------------- desaprovar / editar def test_unapprove_edit_and_rerender_drop_the_final(env, monkeypatch): # noqa: F811 client, engine = env monkeypatch.setattr(worker_module, "REPO_ROOT", engine.settings.data_dir.parent) sid = seed_session(engine) add_ready_clip(engine, sid, layers=["translation"]) spy = RenderSpy(monkeypatch, engine) approve(client) engine.render_pending() assert view(client)["publishFile"] # Desaprovar (voltar para pronto) ou rejeitar: o final deixa de valer. body = client.patch("/v1/clips/1", json={"status": "ready"}, headers=auth()).json() assert body["final"] is None and body["publishFile"] is None approve(client) assert view(client)["final"]["status"] == "pending" # aprovar de novo = final novo engine.render_pending() # Mudar o trecho de um aprovado: volta a ser revisão (renderiza de novo) e o final some. body = client.patch("/v1/clips/1", json={"startS": 95, "endS": 160}, headers=auth()).json() assert body["status"] == "pending" and body["final"] is None and body["publishFile"] is None # Render de revisão novo também derruba qualquer final (ex.: export do editor). engine.db.run("UPDATE clips SET status = 'approved', final_status = 'ready', final_file = 'x-final.mp4' WHERE id = 1") engine.render_pending() # o final está pronto; nada pendente engine.db.run("UPDATE clips SET status = 'pending' WHERE id = 1") engine.render_pending() v = view(client) assert v["status"] == "ready" and v["final"] is None and spy.calls[-1]["dev"] is True # Pedir render de novo (botão) também. approve(client) engine.render_pending() assert client.post("/v1/clips/1/render", headers=auth()).json()["final"] is None def test_unapprove_during_final_render_discards_it(env, monkeypatch): # noqa: F811 client, engine = env sid = seed_session(engine) add_ready_clip(engine, sid, layers=["translation"]) approve(client) def slow_render(eng, clip, session, edit, out, thumb, dev=True): client.patch("/v1/clips/1", json={"status": "ready"}, headers=auth()) # desaprovou no meio do render return None monkeypatch.setattr(editor_api, "ensure_edit", lambda eng, clip, session: {"project": {}}) monkeypatch.setattr(editor_api, "render_clip_edit", slow_render) engine.render_pending() v = view(client) assert v["final"] is None and v["publishFile"] is None and engine._rendering == set() # ---------------------------------------------------------------- quais camadas entraram na revisão def test_review_layers(): lines = [{"s": 0, "e": 1, "text": "hi", "pt": "oi"}] on = layout.merge({"dev": {"translation": True}}) assert editor_api.review_layers(on, lines) == ["translation"] assert editor_api.review_layers(on, None) == [] # fonte em português: nada desenhado assert editor_api.review_layers(layout.merge(), lines) == [] assert editor_api.review_layers(layout.merge({"dev": {"dub": True}}), None) == ["dub"] legacy = layout.merge({"caption": {"translation": True}}) assert editor_api.review_layers(legacy, lines) == ["translation"] def test_render_clip_edit_passes_dev_and_records_layers(env, monkeypatch): # noqa: F811 """render_clip_edit: dev=True grava as camadas da revisão; dev=False não pede tradução nem mexe no registro.""" _client, engine = env sid = seed_session(engine) add_ready_clip(engine, sid, layers=None) seen: list[dict] = [] project = {"cover": {"enabled": False}, "cuts": [{"start": 90, "end": 150, "mode": None}]} monkeypatch.setattr(editor_api, "validate_for", lambda eng, clip, session, data: project) monkeypatch.setattr(editor_api.editor, "effective_settings", lambda base, p: layout.merge({"dev": {"translation": True}})) monkeypatch.setattr(editor_api, "translation_for", lambda eng, clip, p, base, dev=True: [{"s": 0, "e": 1, "text": "hi", "pt": "oi"}] if dev else None) monkeypatch.setattr(editor_api.editor_render, "render_project", lambda *a, **k: seen.append({"dev": k["dev"], "translation": k["translation"]})) monkeypatch.setattr(editor_api.media, "thumbnail", lambda *a, **k: None) monkeypatch.setattr(editor_api.media, "pick_encoder", lambda *a, **k: []) session = engine.db.get("SELECT * FROM sessions WHERE id = ?", sid) clip = engine.db.get("SELECT * FROM clips WHERE id = 1") out = engine.settings.clips_dir / "clip-1.mp4" editor_api.render_clip_edit(engine, clip, session, {"project": project}, out, out.with_suffix(".jpg")) assert seen[-1]["dev"] is True and seen[-1]["translation"] assert json.loads(engine.db.get("SELECT review_dev_json FROM clips WHERE id = 1")["review_dev_json"]) == ["translation"] final = engine.settings.clips_dir / "clip-1-final.mp4" editor_api.render_clip_edit(engine, clip, session, {"project": project}, final, final.with_suffix(".jpg"), dev=False) assert seen[-1] == {"dev": False, "translation": None} assert json.loads(engine.db.get("SELECT review_dev_json FROM clips WHERE id = 1")["review_dev_json"]) == ["translation"] # ---------------------------------------------------------------- limpeza e migração def test_prune_keeps_segments_that_the_final_still_needs(env, monkeypatch): # noqa: F811 _client, engine = env monkeypatch.setattr(worker_module, "REPO_ROOT", engine.settings.data_dir.parent) sid = seed_session(engine) # blocos de 30 s, todos "velhos" (wall_end ≈ 1970) engine.db.run("INSERT INTO clips (id, session_id, peak_s, start_s, end_s, score, source, status, review_dev_json, created_at," " updated_at) VALUES (1, ?, 100, 90, 110, 8, 'chat', 'ready', '[\"translation\"]', 'x', 'x')", sid) engine.db.run("INSERT INTO clips (id, session_id, peak_s, start_s, end_s, score, source, status, review_dev_json, created_at," " updated_at) VALUES (2, ?, 200, 190, 200, 8, 'chat', 'ready', '[]', 'x', 'x')", sid) engine.db.run("INSERT INTO clips (id, session_id, peak_s, start_s, end_s, score, source, status, final_status, created_at," " updated_at) VALUES (3, ?, 400, 400, 410, 8, 'chat', 'approved', 'error', 'x', 'x')", sid) engine.prune() kept = {r["idx"] for r in engine.db.all("SELECT idx FROM segments WHERE session_id = ? AND deleted = 0", sid)} assert kept == {3, 13} # 90–110 s (revisão com tradução) e 400–410 s (final com erro); o 190–200 s (limpo) saiu def test_migration_v14_backfills_old_clips(tmp_path): path = tmp_path / "clipper.db" conn = sqlite3.connect(path) # banco como estava na v13 for script in db_module.SCHEMA[:13]: for statement in db_module._split(script): conn.execute(statement) conn.execute("PRAGMA user_version = 13") conn.execute("INSERT INTO sessions (id, platform, kind, url, status, dir, started_at) VALUES (1, 'twitch', 'live', 'u', 'done', '', 'x')") rows = [(1, "approved", "a.mp4", None), (2, "approved", "b.mp4", '{"lines": []}'), (3, "published", "c.mp4", '{"lines": []}'), (4, "ready", "d.mp4", None), (5, "published", "e.mp4", None), (6, "candidate", None, None)] for cid, status, file, translation in rows: conn.execute("INSERT INTO clips (id, session_id, peak_s, start_s, end_s, score, source, status, file, translation_json," " created_at, updated_at) VALUES (?, 1, 1, 0, 10, 1, 'chat', ?, ?, ?, 'x', 'u')", (cid, status, file, translation)) conn.commit() conn.close() db = Database(path) got = {r["id"]: (r["review_dev_json"], r["final_status"], r["final_file"]) for r in db.all("SELECT id, review_dev_json, final_status, final_file FROM clips")} db.close() assert got == { 1: ("[]", "ready", "a.mp4"), # sem tradução: o arquivo já era limpo → é o final 2: (None, "pending", None), # com tradução e aprovado: renderiza o final 3: (None, None, None), # publicado (já saiu): só gera final se pedirem (POST /final) 4: ("[]", None, None), 5: ("[]", "ready", "e.mp4"), 6: (None, None, None), }