Files
aigc-home/calliope-backend/tests/test_video_continue.py
T

413 lines
14 KiB
Python

"""Continue-from-previous scenes: enqueue-time video validation + source resolution."""
from __future__ import annotations
import asyncio
import json
from pathlib import Path
import pytest
from calliope.agent.video_agent import enqueue_video_jobs
from calliope.comfyui.client import ComfyUIClient
from calliope.config import settings
from calliope.db import get_db
from calliope.queue.manager import queue_manager
from calliope.queue.worker import queue_worker
# One prompt node, one video input slot — the minimum viable "continue" workflow.
VIDEO_WORKFLOW = {
"10": {
"class_type": "CLIPTextEncode",
"inputs": {"text": ""},
"_meta": {"title": "Main Prompt (Input:prompt)"},
},
"20": {
"class_type": "LoadVideo",
"inputs": {"file": ""},
"_meta": {"title": "Previous Clip (Input:video)"},
},
}
# Same but the video slot is missing entirely — must be rejected at enqueue.
NO_VIDEO_WORKFLOW = {
"10": {
"class_type": "CLIPTextEncode",
"inputs": {"text": ""},
"_meta": {"title": "Main Prompt (Input:prompt)"},
},
}
def _mk_project(client, title: str) -> int:
return client.post("/api/projects", json={"title": title}).json()["id"]
def _add_scene(client, pid: int, order: int, **extra) -> dict:
payload = {"order_index": order, "heading": f"S{order}", **extra}
return client.post(f"/api/projects/{pid}/scenes", json=payload).json()
def _set_chain(client, pid: int, scene_id: int, on: bool) -> None:
r = client.patch(
f"/api/projects/{pid}/scenes/{scene_id}", json={"chain_from_prev": on}
)
assert r.status_code == 200
def _insert_workflow(conn, name: str, wf_json: dict) -> int:
cur = conn.execute(
"""
INSERT INTO workflows (name, kind, workflow_json, input_schema, output_schema, is_enabled)
VALUES (?, 'video', ?, '[]', '[]', 1)
""",
(name, json.dumps(wf_json)),
)
conn.commit()
return int(cur.lastrowid)
def _job_payloads(pid: int) -> list[dict]:
conn = get_db(settings.db_path)
try:
rows = conn.execute(
"SELECT payload_json FROM jobs WHERE project_id = ? AND kind = 'video' "
"ORDER BY id",
(pid,),
).fetchall()
return [json.loads(r["payload_json"]) for r in rows]
finally:
conn.close()
def _touch_clip(name: str) -> str:
root = Path(settings.assets_dir)
root.mkdir(parents=True, exist_ok=True)
path = root / name
path.write_bytes(b"mp4-placeholder")
return str(path)
def test_continue_scene_requires_video_input_role(client):
pid = _mk_project(client, "No Video WF")
_add_scene(client, pid, 1)
scene2 = _add_scene(client, pid, 2)
_set_chain(client, pid, scene2["id"], True)
conn = get_db(settings.db_path)
try:
_insert_workflow(conn, "no-video", NO_VIDEO_WORKFLOW)
finally:
conn.close()
try:
asyncio.run(enqueue_video_jobs(pid))
except ValueError as exc:
assert "no video input" in str(exc)
assert "(Input:video)" in str(exc)
else:
raise AssertionError("expected ValueError for workflow without video role")
# Supersede + video_path clear happened for scene 1 before the failure on
# scene 2; the failing scene must not have produced a job.
assert len(_job_payloads(pid)) == 1
def test_continue_scene_uses_previous_clip_path(client):
pid = _mk_project(client, "Prev Clip")
_add_scene(client, pid, 1)
scene2 = _add_scene(client, pid, 2)
_set_chain(client, pid, scene2["id"], True)
clip = _touch_clip("prev-clip.mp4")
conn = get_db(settings.db_path)
try:
wid = _insert_workflow(conn, "video-wf", VIDEO_WORKFLOW)
conn.execute(
"UPDATE scenes SET video_path = ? WHERE order_index = 1 AND project_id = ?",
(clip, pid),
)
conn.commit()
finally:
conn.close()
# Re-generate only the continue scene: scene 1 is not in the batch, so its
# clip stays on disk and is injected directly (no worker deferral needed).
jobs = asyncio.run(enqueue_video_jobs(pid, scene_ids=[scene2["id"]]))
payloads = _job_payloads(pid)
assert len(payloads) == 1
video_values = payloads[0]["input_values"]
# Node 20 (Input:video) holds the previous scene's local clip path.
assert video_values["20"] == clip
assert "continue_source" not in payloads[0]
assert jobs[0]["workflow_id"] == wid
def test_continue_scene_defers_to_worker_without_clip(client):
pid = _mk_project(client, "Deferred Clip")
_add_scene(client, pid, 1)
scene2 = _add_scene(client, pid, 2)
_set_chain(client, pid, scene2["id"], True)
conn = get_db(settings.db_path)
try:
_insert_workflow(conn, "video-wf", VIDEO_WORKFLOW)
finally:
conn.close()
jobs = asyncio.run(enqueue_video_jobs(pid))
payloads = _job_payloads(pid)
assert len(payloads) == 2
assert payloads[1]["continue_source"] == {"scene_order_index": 2}
assert "20" not in payloads[1]["input_values"]
assert jobs[1]["scene_id"] == scene2["id"]
def test_continue_scene_on_first_scene_raises(client):
pid = _mk_project(client, "First Scene")
scene1 = _add_scene(client, pid, 1)
_set_chain(client, pid, scene1["id"], True)
conn = get_db(settings.db_path)
try:
_insert_workflow(conn, "video-wf", VIDEO_WORKFLOW)
finally:
conn.close()
try:
asyncio.run(enqueue_video_jobs(pid))
except ValueError as exc:
assert "no previous clip exists yet" in str(exc)
else:
raise AssertionError("expected ValueError for continue on first scene")
# Nothing was enqueued for the failing scene.
assert _job_payloads(pid) == []
def test_continue_scene_explicit_value_wins_over_previous(client):
pid = _mk_project(client, "Explicit Clip")
_add_scene(client, pid, 1)
scene2 = _add_scene(client, pid, 2)
_set_chain(client, pid, scene2["id"], True)
conn = get_db(settings.db_path)
try:
wid = _insert_workflow(conn, "video-wf", VIDEO_WORKFLOW)
finally:
conn.close()
explicit_clip = _touch_clip("user-upload.mp4")
jobs = asyncio.run(enqueue_video_jobs(pid, input_values_override={"20": explicit_clip}))
payloads = _job_payloads(pid)
assert len(payloads) == 2
assert payloads[1]["input_values"]["20"] == explicit_clip
assert "continue_source" not in payloads[1]
assert jobs[1]["workflow_id"] == wid
def test_non_continue_scene_untouched(client):
pid = _mk_project(client, "Plain Scenes")
_add_scene(client, pid, 1)
_add_scene(client, pid, 2)
conn = get_db(settings.db_path)
try:
_insert_workflow(conn, "video-wf", VIDEO_WORKFLOW)
finally:
conn.close()
asyncio.run(enqueue_video_jobs(pid))
payloads = _job_payloads(pid)
assert len(payloads) == 2
for payload in payloads:
assert "continue_source" not in payload
assert "chain_from_prev" not in payload
assert "scene_order_index" not in payload
assert "chain_replace_value" not in payload
assert "20" not in payload["input_values"]
def _last_job_row(pid: int) -> dict:
conn = get_db(settings.db_path)
try:
row = conn.execute(
"SELECT * FROM jobs WHERE project_id = ? AND kind = 'video' ORDER BY id DESC LIMIT 1",
(pid,),
).fetchone()
assert row is not None
return dict(row)
finally:
conn.close()
def _scene_ids(pid: int) -> list[int]:
conn = get_db(settings.db_path)
try:
rows = conn.execute(
"SELECT id FROM scenes WHERE project_id = ? ORDER BY order_index", (pid,)
).fetchall()
return [r["id"] for r in rows]
finally:
conn.close()
async def _fake_history(_client, _prompt_id):
"""A successful ComfyUI history with one video output named out.mp4."""
return {
"status": {"status_str": "success", "completed": True},
"outputs": {
"99": {"videos": [{"filename": "out.mp4", "subfolder": "", "type": "output"}]}
},
}
def _stub_comfy(monkeypatch, captured: dict) -> list[str]:
"""Run the worker's real (non-dry) path with ComfyUI faked in-process.
The live worker (started by the TestClient lifespan) is paused so it can
not claim the pending jobs; queue_prompt captures the patched workflow so
tests can assert on it; upload_video records which local path
prepare_media_inputs handed it; download_image writes out.mp4. Returns
the list that collects uploaded local paths.
"""
queue_manager.paused = True
uploads: list[str] = []
async def fake_upload_video(self, path, subfolder="calliope"):
uploads.append(str(path))
return f"{subfolder}/{Path(path).name}"
async def fake_queue_prompt(self, workflow):
captured.update(workflow)
return "test-prompt-id"
async def fake_download(self, filename, subfolder="", folder_type="output", dest=None):
dest.write_bytes(b"mp4-placeholder")
return dest
async def fake_health(self):
return True
monkeypatch.setattr(ComfyUIClient, "health", fake_health)
monkeypatch.setattr(ComfyUIClient, "upload_video", fake_upload_video)
monkeypatch.setattr(ComfyUIClient, "queue_prompt", fake_queue_prompt)
monkeypatch.setattr(ComfyUIClient, "download_image", fake_download)
monkeypatch.setattr(queue_worker, "_poll_history", _fake_history)
# conftest sets dry_run=True for placeholder generation; the assertions
# here need the real patch path, so turn it off for the direct _run_job.
monkeypatch.setattr(settings, "dry_run", False)
return uploads
def test_worker_resolves_continue_source_into_video_node(client, monkeypatch):
"""Continue_source job: worker injects the earlier clip before patching."""
pid = _mk_project(client, "Worker Resolve")
_add_scene(client, pid, 1)
scene2 = _add_scene(client, pid, 2)
_set_chain(client, pid, scene2["id"], True)
clip = _touch_clip("worker-resolve.mp4")
conn = get_db(settings.db_path)
try:
wid = _insert_workflow(conn, "video-wf", VIDEO_WORKFLOW)
conn.execute(
"UPDATE scenes SET video_path = ? WHERE order_index = 1 AND project_id = ?",
(clip, pid),
)
conn.commit()
finally:
conn.close()
# Same enqueue shape as the deferred batch case: scene 1 renders first, so
# at enqueue time scene 2's clip does not exist yet and lands in
# continue_source. The worker must resolve it before patching.
jobs = asyncio.run(enqueue_video_jobs(pid))
assert len(jobs) == 2
payloads = _job_payloads(pid)
assert payloads[1].get("continue_source") == {"scene_order_index": 2}
job = _last_job_row(pid)
assert job["workflow_id"] == wid
captured: dict = {}
uploads = _stub_comfy(monkeypatch, captured)
# Re-create the previous clip now: enqueue_video_jobs cleared scene 1's
# video_path row (supersede pass) and the paused real worker can't have
# rendered it. The row points at the file the earlier job would produce.
conn = get_db(settings.db_path)
try:
conn.execute(
"UPDATE scenes SET video_path = ? WHERE order_index = 1 AND project_id = ?",
(clip, pid),
)
conn.commit()
finally:
conn.close()
outputs = asyncio.run(queue_worker._run_job(job))
assert len(outputs) == 1
# The resolved local path reached prepare_media_inputs, which uploaded it.
assert uploads == [clip]
# ...and the video node now carries the uploaded (Comfy-side) file name.
assert captured["20"]["inputs"]["file"] == f"calliope/{Path(clip).name}"
# The scene's own clip was refreshed by the job output.
conn = get_db(settings.db_path)
try:
row = conn.execute(
"SELECT video_path FROM scenes WHERE id = ?", (scene2["id"],)
).fetchone()
assert row["video_path"] == outputs[0]
finally:
conn.close()
def test_worker_fails_continue_job_without_previous_clip(client, monkeypatch):
pid = _mk_project(client, "Worker Missing")
_add_scene(client, pid, 1)
scene2 = _add_scene(client, pid, 2)
_set_chain(client, pid, scene2["id"], True)
conn = get_db(settings.db_path)
try:
_insert_workflow(conn, "video-wf", VIDEO_WORKFLOW)
finally:
conn.close()
asyncio.run(enqueue_video_jobs(pid))
payloads = _job_payloads(pid)
assert payloads[1].get("continue_source") == {"scene_order_index": 2}
job = _last_job_row(pid)
# Run only the continue job: its earlier scene has no clip on disk yet,
# so the worker must fail it with a clear message (the loop records it
# via mark_failed + job.failed event).
captured: dict = {}
_stub_comfy(monkeypatch, captured)
with pytest.raises(RuntimeError) as excinfo:
asyncio.run(queue_worker._run_job(job))
message = str(excinfo.value)
assert "Continue scene 2" in message
assert "previous clip (scene 1) has no video file" in message
assert "generate the earlier clip first" in message
# Nothing reached ComfyUI.
assert captured == {}
def test_worker_passes_plain_job_unchanged(client, monkeypatch):
pid = _mk_project(client, "Worker Plain")
_add_scene(client, pid, 1)
conn = get_db(settings.db_path)
try:
wid = _insert_workflow(conn, "video-wf", VIDEO_WORKFLOW)
finally:
conn.close()
jobs = asyncio.run(enqueue_video_jobs(pid, scene_ids=[_scene_ids(pid)[0]]))
payloads = _job_payloads(pid)
assert len(payloads) == 1
assert "continue_source" not in payloads[0]
job = _last_job_row(pid)
captured: dict = {}
_stub_comfy(monkeypatch, captured)
outputs = asyncio.run(queue_worker._run_job(job))
assert len(outputs) == 1
# No video value was injected; the LoadVideo node keeps its empty default.
assert captured["20"]["inputs"]["file"] == ""
assert captured["10"]["inputs"]["text"] # scene prompt was filled
assert job["workflow_id"] == wid