mirror of
https://github.com/rennf93/roboco.git
synced 2026-08-03 07:23:24 +02:00
feat(video): 0.19.0 video engine (Remotion) + preview auth + render persistence (#307)
* feat(video): Phase A — VideoEngine origination spine + held-source gates
New default-off engine skeleton: opens a UX/UI authoring task (source=video, assigned to a ux-dev, LOW complexity to clear the dev-needs-subtasks guard) and materializes a held CEO-approval draft (source=video_post). Excludes video_post from all three held-source skip sites; adds the video_draft marker, six config flags, and the feature-flag entries. Origination + gate behavior unit-tested.
* refactor(orchestrator): fold _dispatch_dev_work skip chain into a helper
The per-source if/continue chain grew past xenon's --max-absolute B when the video_post held source joined it. Extract _is_non_dev_dispatch_source (every held-CEO source plus the two Board exploration sources) so the dev loop's skip is one flat call. Behavior-identical.
* feat(video): Phase B — propose_video do-tool (metadata-only, team-gated)
UX/UI dev records a video's composition ref + per-platform captions onto the authoring task's video_draft marker. Team-gated at runtime via _caller_team (Role.DEVELOPER can't tell a ux-dev from a be-dev). Resolves the caller's ACTIVE task via get_active_task_for_agent, not an oldest-first scan that would clobber a second open video task. Metadata only, no render. Wired through do_server + route + schema; added to _DEV_DO.
* feat(video): Phase D — render loop + RemotionRenderer client
Orchestrator-async _video_render_loop renders a completed authoring task's merged composition to MP4 (vertical + square) via the remotion-renderer sidecar and materializes the held video_post draft. RemotionRenderer tars the read-clone's motion/ source, POSTs it, and saves the returned MP4 bytes to a TASK-scoped local path (no shared volume; a composition is reused across videos so a composition-scoped path would clobber an earlier draft). Render failures bounded-retry (read-clone catch-up window, transient sidecar) up to a cap, then terminal-fail. Client tested vs a mock transport; loop vs a mock renderer + real DB.
* feat(video): Phase C — release / spotlight / on-demand video triggers
Three entry points open a UX/UI video-authoring task via VideoEngine.open_video_task: (1) a published release drafts a companion video — best-effort in ReleaseProposalService.approve, never fails the publish; script from the CHANGELOG via the local model with a template fallback. (2) propose_feature_spotlight gains optional wants_video/video_script — best-effort, gated on video_on_spotlight, default-off leaves the spotlight flow byte-for-byte unchanged. (3) POST /video/request (CEO-only) for an on-demand brief, with clean disabled/not_opened responses. All gated on video_engine_enabled.
* fix(video): savepoint-isolate video-task inserts (F042 poisoned session)
The best-effort try/except around open_video_task (release-publish + spotlight hooks) swallowed the Python exception, but a DBAPI error at the insert flush left the shared session must-rollback — so the caller's next commit (release finalize / request boundary) threw PendingRollbackError: the release stuck 'pending' after actually publishing, or the spotlight draft + HTTP response were lost. Wrap both inserts (open_video_task, _originate_video_post) in a begin_nested savepoint (the repo's established F042 pattern) so a DB error rolls back only the insert. open_video_task returns None (every caller already handles it); _originate_video_post propagates to the render loop's handler. Regression test: an insert FK error returns None with the session left usable. Dormant while the flags were off; armed on the NAS.
* feat(video): Phase G — motion/ package + remotion-renderer sidecar + compose
In-repo Remotion v4 motion/ package (ReleaseAnnouncement composition; calculateMetadata returns 1080x1920 vertical / 1080x1080 square from inputProps.orientation) + a credential-free remotion-renderer sidecar: untar the POSTed motion/ source, bundle (LRU-cached per source sha), selectComposition + renderMedia h264, stream the MP4 bytes back — matching the RemotionRenderer client contract. docker/remotion.Dockerfile on Debian (Chrome apt deps, build-time Chrome pre-warm, ffmpeg bundled in @remotion/renderer). Wired into both compose files (roboco_default only, shm_size 1gb, /health check) + the release publish matrix. Verified via a real local render of both cuts; the Debian docker build is the CEO's to run.
* chore(video): D-hardening — video_post source_task_id + render-loop docstring
Add a source_task_id back-reference to the video_post held-draft marker (traceability from a draft to its authoring task; also makes the render loop's two-key idempotency check wireable later). Fix the render-loop test's stale docstring ('never retried' -> bounded-retry). Both from the Phase D critic's non-blocking follow-ups.
* feat(video): Phase E1 — VideoPostService + heartbeat mutex (approve->post)
CEO-approve->post service: heartbeat-renewed Redis mutex (fail-closed, grace=ttl-2*heartbeat), re-read-in-lock double-post guard, per-platform durable commits (asyncio.shield-ed, settle-before-rollback on lock-loss), all writes inside the lock (captions validated pre-lock, applied in-lock — no stale whole-column clobber), idempotent, per-platform retry-skip. Poster interfaces (X/TikTok, mocked here). Reject + list-held-drafts. Survived 3 adversarial rounds; residual = a crash in the poster->commit window (CEO-gated low-freq, documented).
* fix(video): G-hardening — renderer leaks + Share Tech Mono brand font
Sidecar: give bundle() an explicit outDir tracked + deleted on LRU eviction (was leaking ~19MB remotion-webpack-bundle-* per source); res.on('close') cleanup so an aborted/retried download no longer leaks its remotion-out-* MP4 dir. Fonts: vendor Share Tech Mono (roboco-website brand font) as the display face (self-hosted woff2, 400-weight, headline fontWeight 700->400 to avoid faux-bold) + self-hosted Inter body — no gstatic fetch at render time (lsof-verified). Extras: composition_id whitelist (400) + Multer error middleware (400/413).
* feat(video): Phase E2 — X v2 + TikTok posters, tiktok_credentials, routes
LiveXVideoPoster (X v2 chunked media upload: init/append/finalize/STATUS-poll -> tweet w/ media_ids, OAuth1 signer reused). LiveTikTokPoster (OAuth2 inbox: init -> chunked PUT with asymmetric final chunk -> status-fetch; 401 -> refresh_token grant, rotated token persisted). tiktok_credentials Fernet singleton + migration 062 (single head). Routes: CEO approve/reject + list held drafts + write-only tiktok creds, wiring real posters into VideoPostService. Residual: a lock-loss right after a token-refresh flush can discard the rotated token (same rare CEO-gated class as the documented post->commit window).
* feat(video): Phase F — panel video-post queue + TikTok creds card + flags
video-post-queue.tsx: <video> MP4 preview with 9:16/1:1 cut switch, per-platform editable captions (280/2200 counters, over-limit disables approve), approve/reject, Request-a-video dialog. tiktok-credentials-card.tsx (4 write-only OAuth2 fields). feature-flags-card inlines TikTokCredentialsForm under video_engine_enabled. Mounted in command-center. tsc/eslint clean, 273 panel tests green. NOTE: needs the GET /video/posts/{id}/media route + mp4_paths on VideoPostResponse (folded into H) for the preview source.
* feat(video): Phase H — media route + e2e smoke + NAS arming + docs
GET /video/posts/{id}/media?cut= (CEO-gated FileResponse of the rendered MP4; closes the panel preview gap) + mp4_paths on VideoPostResponse. e2e smoke tests/e2e_smoke/test_video_pipeline.py (full flow, sidecar+X/TikTok mocked; asserts dispatcher skips, render-loop materialize, propose_video team-gate, approve idempotency). NAS arming: docker-compose.yml/.yaml ROBOCO_VIDEO_ENGINE_ENABLED/ON_RELEASE/ON_SPOTLIGHT default-on (.yaml resynced to .yml); registry stays off. CLAUDE.md video-engine section + CHANGELOG. Fixed 2 pre-existing route-test pollution leaks. Full suite 11763 passed.
* fix(video): auth-carrying preview, media route confinement, VideoPost type drift
Three fixes along the video preview path:
1. panel video preview auth: the <video> element was pointed straight at
GET /video/posts/{id}/media, but a native <video src> GET carries none
of axios's X-Agent-ID/X-Agent-Role headers — so in the default
header-trust deployment the request 401s. Fetch the cut via
videoApi.getMediaBlob (axios, responseType: blob) and drive <video>
off a URL.createObjectURL result instead. The object URL is revoked
on cut-change (the previous cut's URL) and on unmount, so neither
cut switches nor row teardown leak blob URLs.
2. backend media route confinement: GET /video/posts/{id}/media now
resolves mp4_path and refuses it with 404 when it falls outside
settings.video_output_dir. Defense-in-depth against any future
writer of mp4_paths serving files from arbitrary disk locations.
3. panel VideoPost type/comment drift: added mp4_paths to the
VideoPost interface (the committed VideoPostResponse already
carries it), and corrected the stale comment on videoMediaUrl
that claimed no route served the rendered bytes — the route has
existed since the media endpoint landed; the comment now describes
why getMediaBlob exists instead of a direct <video src>.
* Persist rendered videos to data in physical storage.
* ++
* docs(video): 0.18.0 CHANGELOG entry + RAG + map reference for video engine
- Move the video engine bullet from [Unreleased] into [0.18.0] and note
the ROBOCO_VIDEO_OUTPUT_DIR bind-mount persistence.
- Add docs/rag/architecture/video-engine.md (mirrors x-engine.md shape:
enable/disable, three triggers, render loop + sidecar, CEO gate, media
route confinement, credentials).
- Reference the video render loop in docs/map/orchestrator.md's engine list.
* chore(video): re-bump to 0.19.0 + sync registry compose defaults
Version was wrongly bumped to 0.18.0; 0.18.0 is an already-released
section. Restore its 2026-07-04 date and move the video-engine CHANGELOG
bullet into a new [0.19.0] - 2026-07-05 section above it. Bump
pyproject.toml, roboco/__init__.py, roboco/config.py (app_version),
panel/package.json, and the motion/README inputProps example to 0.19.0.
docker-compose.registry.yml: add ROBOCO_VIDEO_ENGINE_ENABLED /
_VIDEO_ON_RELEASE / _VIDEO_ON_SPOTLIGHT defaulted false (NAS arms them
true), and comment out the video-renders bind mount with a short note
so the public registry image ships video off by default. Structural
sync with docker-compose.yml maintained.
* fix(video): rate-limit /render + reflow motion/README
CodeQL flagged js/missing-rate-limiting on the renderer /render route.
The sidecar is container-network-only with one trusted caller (the
orchestrator, which renders cuts serially), so this limiter is a
retry-storm ceiling (30/min, well above legit render rate), not the
primary control. Also reflows motion/README.md hard-wrapped prose that
failed the markdown quality gate.
* fix(build): finish pnpm 11 migration + regen verb tables
The panel Docker image build failed on `pnpm install --frozen-lockfile`:
node:22-alpine's corepack resolved to its bundled pnpm 11, but
panel/package.json pinned packageManager to pnpm@10.25.0, and pnpm 11
refuses to run against that pin. The Dockerfiles were already written for
pnpm 11 (comments, CI=true, strictDepBuilds); the package.json pin was the
stale outlier. Finish the migration instead of working around it:
- panel/package.json: packageManager pnpm@10.25.0 -> pnpm@11.10.0; drop the
`pnpm` field (pnpm 11 ignores it — build approval lives in
panel/pnpm-workspace.yaml's allowBuilds). Lockfile unchanged (pnpm 11
accepts it as-is); frozen-lockfile verified.
- remotion-renderer/package.json: pin packageManager pnpm@11.10.0 for
determinism (was relying on corepack's implicit default); engines.node
>=22.13 (pnpm 11 requirement).
- docker/panel.Dockerfile + docker/remotion.Dockerfile: `corepack prepare
pnpm@11.10.0 --activate` so the build uses the pinned version explicitly
instead of trusting corepack's bundled default (which a future
node:22-alpine could change).
- .github/workflows/panel-ci.yml: Node 20 -> 22 (pnpm 11 requires
Node >=22.13; Node 20 fails the engines check).
Also regenerate agents/prompts/_generated/{developer,head_marketing,verbs}.md
— the video engine added propose_video and extended propose_feature_spotlight
(wants_video, video_script) but the verb tables weren't refreshed, failing
the foundation-check quality gate.
* chore(build): approve esbuild build script in remotion pnpm-workspace.yaml
pnpm 11 generated this file with a placeholder ('set this to true or false')
during install; resolve it to true so local dev of the renderer doesn't
re-prompt. esbuild's postinstall only verifies the prebuilt platform binary
(@esbuild/<platform> is installed as an optional dep), so approving it is
safe and silences the ERR_PNPM_IGNORED_BUILDS warning.
* fix(build): copy pnpm-workspace.yaml into panel + remotion images
pnpm 11 hard-errors with [ERR_PNPM_IGNORED_BUILDS] (exit 1) when a
dependency ships a postinstall script that isn't approved in
allowBuilds. Both Dockerfiles copied only package.json + pnpm-lock.yaml,
so the build-approval map in pnpm-workspace.yaml never made it into the
image — the remotion image build died on esbuild@0.28.1's postinstall.
Copy pnpm-workspace.yaml alongside the manifests in both images. In
panel, this also drops the --config.strictDepBuilds=false workaround:
with sharp and unrs-resolver now approved, their postinstalls run and
install the platform-specific binaries (previously skipped, leaving
sharp without its @img/sharp-* binary at runtime).
Verified locally: remotion + panel `pnpm install --frozen-lockfile`
exit 0 with the workspace file present; both exit 1 without it.
---------
Co-authored-by: Renn F <rennf93@users.noreply.github.com>
This commit is contained in:
Renzo F
@@ -0,0 +1,407 @@
|
||||
"""The orchestrator video-render loop: dormant when off; the cycle wrapper
|
||||
iterates + commits (mocked wiring test, mirrors test_dep_update_loop.py); the
|
||||
per-task render (mocked renderer/workspace, real DB) renders both cuts, holds
|
||||
one video_post draft, and is idempotent (a rendered task is never re-rendered;
|
||||
a failed render bounded-retries up to a cap, then is terminal) — never itself
|
||||
committing, so it never pollutes the session-scoped
|
||||
shared test database the way routing it through the committing cycle wrapper
|
||||
would.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import asyncio
|
||||
from contextlib import asynccontextmanager
|
||||
from pathlib import Path
|
||||
from types import SimpleNamespace
|
||||
from typing import TYPE_CHECKING, Any, cast
|
||||
from unittest.mock import AsyncMock, MagicMock, call, patch
|
||||
|
||||
import pytest
|
||||
from roboco.config import settings as cfg
|
||||
from roboco.db.tables import AgentTable, ProjectTable
|
||||
from roboco.foundation import identity as _foundation
|
||||
from roboco.foundation.policy.content import markers
|
||||
from roboco.models.base import AgentRole, AgentStatus, Team
|
||||
from roboco.models.base import TaskStatus as TS
|
||||
from roboco.runtime.orchestrator import (
|
||||
_MAX_VIDEO_RENDER_ATTEMPTS,
|
||||
AgentOrchestrator,
|
||||
)
|
||||
from roboco.services.task import VIDEO_POST_SOURCE, get_task_service
|
||||
from roboco.services.video_engine import VideoEngine
|
||||
from sqlalchemy import select
|
||||
|
||||
if TYPE_CHECKING:
|
||||
from sqlalchemy.ext.asyncio import AsyncSession
|
||||
|
||||
SYSTEM_UUID = _foundation.AGENTS["system"].uuid
|
||||
SECRETARY_UUID = _foundation.AGENTS["secretary-1"].uuid
|
||||
UX_DEV_1_UUID = _foundation.AGENTS["ux-dev-1"].uuid
|
||||
UX_DEV_2_UUID = _foundation.AGENTS["ux-dev-2"].uuid
|
||||
SLUG = "roboco"
|
||||
ONE = 1
|
||||
TWO = 2
|
||||
|
||||
|
||||
def _orch() -> Any:
|
||||
return AgentOrchestrator.__new__(AgentOrchestrator)
|
||||
|
||||
|
||||
class _FakeRenderer:
|
||||
"""Records every render() call; returns a deterministic path or raises."""
|
||||
|
||||
def __init__(self, *, fail: bool = False) -> None:
|
||||
self.calls: list[dict[str, str]] = []
|
||||
self.fail = fail
|
||||
|
||||
async def render(
|
||||
self,
|
||||
*,
|
||||
source_dir: str,
|
||||
composition_id: str,
|
||||
input_props: dict[str, Any],
|
||||
orientation: str,
|
||||
render_key: str,
|
||||
) -> str:
|
||||
_ = input_props
|
||||
self.calls.append(
|
||||
{
|
||||
"source_dir": source_dir,
|
||||
"composition_id": composition_id,
|
||||
"orientation": orientation,
|
||||
"render_key": render_key,
|
||||
}
|
||||
)
|
||||
if self.fail:
|
||||
raise RuntimeError("render blew up")
|
||||
return f"/fake-out/{composition_id}-{orientation}.mp4"
|
||||
|
||||
|
||||
def _db_ctx(db: Any) -> Any:
|
||||
@asynccontextmanager
|
||||
async def _ctx() -> Any:
|
||||
yield db
|
||||
|
||||
return _ctx
|
||||
|
||||
|
||||
async def _seed(session: AsyncSession) -> None:
|
||||
for uuid, slug, role, team in (
|
||||
(SYSTEM_UUID, "system", AgentRole.SYSTEM, None),
|
||||
(SECRETARY_UUID, "secretary-1", AgentRole.SECRETARY, None),
|
||||
(UX_DEV_1_UUID, "ux-dev-1", AgentRole.DEVELOPER, Team.UX_UI),
|
||||
(UX_DEV_2_UUID, "ux-dev-2", AgentRole.DEVELOPER, Team.UX_UI),
|
||||
):
|
||||
if await session.get(AgentTable, uuid) is None:
|
||||
session.add(
|
||||
AgentTable(
|
||||
id=uuid,
|
||||
name=slug,
|
||||
slug=slug,
|
||||
role=role,
|
||||
team=team,
|
||||
status=AgentStatus.ACTIVE,
|
||||
model_config={},
|
||||
system_prompt="x",
|
||||
capabilities=[],
|
||||
permissions={},
|
||||
metrics={},
|
||||
)
|
||||
)
|
||||
await session.flush()
|
||||
existing = await session.execute(
|
||||
select(ProjectTable).where(ProjectTable.slug == SLUG)
|
||||
)
|
||||
if existing.scalar_one_or_none() is None:
|
||||
session.add(
|
||||
ProjectTable(
|
||||
name="RoboCo",
|
||||
slug=SLUG,
|
||||
git_url="https://github.com/x/roboco.git",
|
||||
default_branch="master",
|
||||
protected_branches=["master"],
|
||||
assigned_cell=Team.BACKEND,
|
||||
created_by=SYSTEM_UUID,
|
||||
is_active=True,
|
||||
)
|
||||
)
|
||||
await session.flush()
|
||||
|
||||
|
||||
def _enable(monkeypatch: pytest.MonkeyPatch, **overrides: object) -> None:
|
||||
monkeypatch.setattr(cfg, "video_engine_enabled", True)
|
||||
monkeypatch.setattr(cfg, "self_heal_project_slug", SLUG)
|
||||
monkeypatch.setattr(cfg, "video_max_open_posts", 5)
|
||||
monkeypatch.setattr(cfg, "video_render_interval_seconds", 120.0)
|
||||
for key, value in overrides.items():
|
||||
monkeypatch.setattr(cfg, key, value)
|
||||
|
||||
|
||||
async def _make_completed_video_task(
|
||||
session: AsyncSession, *, occasion: str, composition_id: str | None
|
||||
) -> Any:
|
||||
engine = VideoEngine(session)
|
||||
task = await engine.open_video_task(
|
||||
occasion=occasion,
|
||||
script="Here's what shipped",
|
||||
platforms=["x", "tiktok"],
|
||||
brief="Announce the release",
|
||||
)
|
||||
assert task is not None
|
||||
if composition_id is not None:
|
||||
draft = markers.get_video_draft(task) or {}
|
||||
markers.set_video_draft(
|
||||
task,
|
||||
{
|
||||
**draft,
|
||||
"composition_id": composition_id,
|
||||
"input_props": {"title": "hello"},
|
||||
"x_caption": "Check out our new release!",
|
||||
"tiktok_caption": "New release, check it out",
|
||||
"platforms": ["x", "tiktok"],
|
||||
},
|
||||
)
|
||||
task.status = TS.COMPLETED
|
||||
await session.flush()
|
||||
return task
|
||||
|
||||
|
||||
def _render_patches(renderer: _FakeRenderer, workspace: Any) -> Any:
|
||||
return (
|
||||
patch(
|
||||
"roboco.services.remotion_client.get_remotion_renderer",
|
||||
lambda: renderer,
|
||||
),
|
||||
patch(
|
||||
"roboco.services.workspace.get_workspace_service",
|
||||
lambda _db: workspace,
|
||||
),
|
||||
)
|
||||
|
||||
|
||||
def _fake_workspace() -> Any:
|
||||
return SimpleNamespace(
|
||||
ensure_read_clone=AsyncMock(return_value=Path("/fake-clone"))
|
||||
)
|
||||
|
||||
|
||||
# --------------------------------------------------------------------------- #
|
||||
# _video_render_loop dormancy
|
||||
# --------------------------------------------------------------------------- #
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_loop_returns_immediately_when_disabled(
|
||||
monkeypatch: pytest.MonkeyPatch,
|
||||
) -> None:
|
||||
monkeypatch.setattr(cfg, "video_engine_enabled", False)
|
||||
stub = cast("AgentOrchestrator", SimpleNamespace(_running=True))
|
||||
await asyncio.wait_for(AgentOrchestrator._video_render_loop(stub), timeout=1.0)
|
||||
|
||||
|
||||
# --------------------------------------------------------------------------- #
|
||||
# _run_video_render_cycle — wiring only (mocked db/service, mirrors
|
||||
# test_dep_update_loop.py); the substantive render behavior is covered below
|
||||
# against _render_video_task directly, which never commits.
|
||||
# --------------------------------------------------------------------------- #
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_run_cycle_processes_each_completed_task_and_commits() -> None:
|
||||
orch = _orch()
|
||||
task_a = MagicMock()
|
||||
task_b = MagicMock()
|
||||
db = MagicMock()
|
||||
db.commit = AsyncMock()
|
||||
task_svc = MagicMock()
|
||||
task_svc.list_completed_video_tasks = AsyncMock(return_value=[task_a, task_b])
|
||||
orch._render_video_task = AsyncMock()
|
||||
with (
|
||||
patch("roboco.db.get_db_context", _db_ctx(db)),
|
||||
patch("roboco.services.task.get_task_service", return_value=task_svc),
|
||||
):
|
||||
await orch._run_video_render_cycle()
|
||||
assert orch._render_video_task.await_args_list == [
|
||||
call(db, task_a),
|
||||
call(db, task_b),
|
||||
]
|
||||
db.commit.assert_awaited_once()
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_run_cycle_with_no_completed_tasks_still_commits() -> None:
|
||||
orch = _orch()
|
||||
db = MagicMock()
|
||||
db.commit = AsyncMock()
|
||||
task_svc = MagicMock()
|
||||
task_svc.list_completed_video_tasks = AsyncMock(return_value=[])
|
||||
orch._render_video_task = AsyncMock()
|
||||
with (
|
||||
patch("roboco.db.get_db_context", _db_ctx(db)),
|
||||
patch("roboco.services.task.get_task_service", return_value=task_svc),
|
||||
):
|
||||
await orch._run_video_render_cycle()
|
||||
orch._render_video_task.assert_not_awaited()
|
||||
db.commit.assert_awaited_once()
|
||||
|
||||
|
||||
# --------------------------------------------------------------------------- #
|
||||
# _render_video_task — real DB (flush only, never commits: the session-scoped
|
||||
# shared test DB stays clean via this test's own rollback teardown), mocked
|
||||
# renderer + workspace clone.
|
||||
# --------------------------------------------------------------------------- #
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_render_video_task_renders_both_cuts_and_materializes_post(
|
||||
db_session: AsyncSession, monkeypatch: pytest.MonkeyPatch
|
||||
) -> None:
|
||||
await _seed(db_session)
|
||||
_enable(monkeypatch)
|
||||
task = await _make_completed_video_task(
|
||||
db_session, occasion="render-both-cuts", composition_id="Intro"
|
||||
)
|
||||
|
||||
renderer = _FakeRenderer()
|
||||
workspace = _fake_workspace()
|
||||
orch = _orch()
|
||||
p1, p2 = _render_patches(renderer, workspace)
|
||||
with p1, p2:
|
||||
await orch._render_video_task(db_session, task)
|
||||
|
||||
workspace.ensure_read_clone.assert_awaited_once_with(SLUG)
|
||||
assert len(renderer.calls) == TWO
|
||||
orientations = {c["orientation"] for c in renderer.calls}
|
||||
assert orientations == {"vertical", "square"}
|
||||
expected_motion_dir = str(Path("/fake-clone") / "motion")
|
||||
assert all(c["source_dir"] == expected_motion_dir for c in renderer.calls)
|
||||
assert all(c["render_key"] == str(task.id) for c in renderer.calls) # task-scoped
|
||||
|
||||
posts = await get_task_service(db_session).list_open_video_posts()
|
||||
assert len(posts) == ONE
|
||||
assert posts[0].source == VIDEO_POST_SOURCE
|
||||
draft = markers.get_video_draft(posts[0])
|
||||
assert draft is not None
|
||||
assert draft["mp4_paths"] == {
|
||||
"vertical": "/fake-out/Intro-vertical.mp4",
|
||||
"square": "/fake-out/Intro-square.mp4",
|
||||
}
|
||||
assert draft["x_caption"] == "Check out our new release!"
|
||||
assert draft["tiktok_caption"] == "New release, check it out"
|
||||
|
||||
source_draft = markers.get_video_draft(task)
|
||||
assert source_draft is not None
|
||||
assert source_draft["render_status"] == "rendered"
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_render_video_task_second_call_is_idempotent(
|
||||
db_session: AsyncSession, monkeypatch: pytest.MonkeyPatch
|
||||
) -> None:
|
||||
await _seed(db_session)
|
||||
_enable(monkeypatch)
|
||||
task = await _make_completed_video_task(
|
||||
db_session, occasion="idempotent", composition_id="Intro"
|
||||
)
|
||||
|
||||
renderer = _FakeRenderer()
|
||||
workspace = _fake_workspace()
|
||||
orch = _orch()
|
||||
p1, p2 = _render_patches(renderer, workspace)
|
||||
with p1, p2:
|
||||
await orch._render_video_task(db_session, task)
|
||||
await orch._render_video_task(db_session, task) # must be a no-op
|
||||
|
||||
assert len(renderer.calls) == TWO # not four — the second call skipped it
|
||||
posts = await get_task_service(db_session).list_open_video_posts()
|
||||
assert len(posts) == ONE
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_render_video_task_skips_task_without_composition_id(
|
||||
db_session: AsyncSession, monkeypatch: pytest.MonkeyPatch
|
||||
) -> None:
|
||||
await _seed(db_session)
|
||||
_enable(monkeypatch)
|
||||
task = await _make_completed_video_task(
|
||||
db_session, occasion="no-composition", composition_id=None
|
||||
)
|
||||
|
||||
renderer = _FakeRenderer()
|
||||
workspace = _fake_workspace()
|
||||
orch = _orch()
|
||||
p1, p2 = _render_patches(renderer, workspace)
|
||||
with p1, p2:
|
||||
await orch._render_video_task(db_session, task)
|
||||
|
||||
assert renderer.calls == []
|
||||
workspace.ensure_read_clone.assert_not_awaited()
|
||||
posts = await get_task_service(db_session).list_open_video_posts()
|
||||
assert posts == []
|
||||
draft = markers.get_video_draft(task)
|
||||
assert draft is not None
|
||||
assert draft.get("render_status") is None
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_render_video_task_single_failure_retries_not_terminal(
|
||||
db_session: AsyncSession, monkeypatch: pytest.MonkeyPatch
|
||||
) -> None:
|
||||
"""One failure bumps the attempt counter but does NOT terminally fail the
|
||||
task — a stale read-clone or a transient sidecar blip must be retried on a
|
||||
later cycle, not silently lost."""
|
||||
await _seed(db_session)
|
||||
_enable(monkeypatch)
|
||||
task = await _make_completed_video_task(
|
||||
db_session, occasion="render-fails-once", composition_id="Intro"
|
||||
)
|
||||
|
||||
renderer = _FakeRenderer(fail=True)
|
||||
workspace = _fake_workspace()
|
||||
orch = _orch()
|
||||
p1, p2 = _render_patches(renderer, workspace)
|
||||
with p1, p2:
|
||||
await orch._render_video_task(db_session, task)
|
||||
|
||||
posts = await get_task_service(db_session).list_open_video_posts()
|
||||
assert posts == []
|
||||
draft = markers.get_video_draft(task)
|
||||
assert draft is not None
|
||||
assert draft["render_attempts"] == ONE
|
||||
assert draft.get("render_status") is None # retried next cycle, not terminal
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_render_video_task_terminal_after_max_attempts(
|
||||
db_session: AsyncSession, monkeypatch: pytest.MonkeyPatch
|
||||
) -> None:
|
||||
"""After _MAX_VIDEO_RENDER_ATTEMPTS failures the task is terminally failed
|
||||
and never rendered again — a genuinely broken composition can't loop."""
|
||||
await _seed(db_session)
|
||||
_enable(monkeypatch)
|
||||
task = await _make_completed_video_task(
|
||||
db_session, occasion="max-attempts", composition_id="Intro"
|
||||
)
|
||||
seeded = markers.get_video_draft(task) or {}
|
||||
markers.set_video_draft(
|
||||
task, {**seeded, "render_attempts": _MAX_VIDEO_RENDER_ATTEMPTS - 1}
|
||||
)
|
||||
await db_session.flush()
|
||||
|
||||
renderer = _FakeRenderer(fail=True)
|
||||
workspace = _fake_workspace()
|
||||
orch = _orch()
|
||||
p1, p2 = _render_patches(renderer, workspace)
|
||||
with p1, p2:
|
||||
await orch._render_video_task(db_session, task) # tips to terminal
|
||||
calls_at_terminal = len(renderer.calls)
|
||||
await orch._render_video_task(db_session, task) # now a no-op
|
||||
|
||||
draft = markers.get_video_draft(task)
|
||||
assert draft is not None
|
||||
assert draft["render_attempts"] == _MAX_VIDEO_RENDER_ATTEMPTS
|
||||
assert draft["render_status"] == "failed"
|
||||
assert len(renderer.calls) == calls_at_terminal # not retried after terminal
|
||||
posts = await get_task_service(db_session).list_open_video_posts()
|
||||
assert posts == []
|
||||
Reference in New Issue
Block a user