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,222 @@
|
||||
"""HeartbeatMutex coverage: acquire (fencing token), heartbeat renew,
|
||||
compare-and-del release, fail-closed on a Redis outage, and the
|
||||
run_guarded cancel-on-lock-loss dance.
|
||||
|
||||
No live Redis in tests (matches the project's `_no_live_redis` fixture); a
|
||||
tiny in-memory fake backs the Lua compare-and-del/compare-and-expire scripts
|
||||
so the fencing semantics are observable without a real Redis.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import asyncio
|
||||
from typing import Any
|
||||
from unittest.mock import AsyncMock, MagicMock, patch
|
||||
|
||||
import pytest
|
||||
from roboco.services.heartbeat_mutex import (
|
||||
HeartbeatLockUnavailable,
|
||||
HeartbeatMutex,
|
||||
)
|
||||
|
||||
_KEY = "roboco:test_mutex:abc"
|
||||
_MIN_RENEWS_AFTER_RECOVERY = 2 # the failed renew, then >=1 recovered one
|
||||
|
||||
|
||||
class _FakeRedis:
|
||||
"""In-memory single-key store backing the mutex's SET NX EX + two Lua
|
||||
scripts (compare-and-del release, compare-and-expire heartbeat)."""
|
||||
|
||||
def __init__(self) -> None:
|
||||
self._store: dict[str, str] = {}
|
||||
self.set_calls: list[tuple[str, str, bool, int]] = []
|
||||
self.eval_calls: list[tuple[str, tuple[Any, ...]]] = []
|
||||
|
||||
async def set(
|
||||
self, name: str, value: str, *, nx: bool = False, ex: int = 0
|
||||
) -> bool:
|
||||
self.set_calls.append((name, value, nx, ex))
|
||||
if nx and name in self._store:
|
||||
return False
|
||||
self._store[name] = value
|
||||
return True
|
||||
|
||||
async def eval(self, script: str, _numkeys: int, *args: Any) -> int:
|
||||
self.eval_calls.append((script, args))
|
||||
key, token = args[0], args[1]
|
||||
if "expire" in script:
|
||||
return 1 if self._store.get(key) == token else 0
|
||||
if self._store.get(key) == token:
|
||||
del self._store[key]
|
||||
return 1
|
||||
return 0
|
||||
|
||||
async def aclose(self) -> None:
|
||||
return None
|
||||
|
||||
|
||||
def _mutex(*, ttl: int = 60, heartbeat: float = 30.0) -> HeartbeatMutex:
|
||||
return HeartbeatMutex(_KEY, ttl_seconds=ttl, heartbeat_seconds=heartbeat)
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_acquire_sets_nx_ex_and_returns_a_fencing_token() -> None:
|
||||
fake = _FakeRedis()
|
||||
with patch("roboco.services.heartbeat_mutex.redis.from_url", return_value=fake):
|
||||
token = await _mutex(ttl=1800).acquire()
|
||||
assert token is not None
|
||||
assert fake.set_calls == [(_KEY, token, True, 1800)]
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_acquire_returns_none_when_already_held() -> None:
|
||||
fake = _FakeRedis()
|
||||
with patch("roboco.services.heartbeat_mutex.redis.from_url", return_value=fake):
|
||||
first = await _mutex().acquire()
|
||||
second = await _mutex().acquire()
|
||||
assert first is not None
|
||||
assert second is None
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_release_is_compare_and_del_spares_a_usurper_lock() -> None:
|
||||
fake = _FakeRedis()
|
||||
with patch("roboco.services.heartbeat_mutex.redis.from_url", return_value=fake):
|
||||
mutex = _mutex()
|
||||
token = await mutex.acquire()
|
||||
assert token is not None
|
||||
# A usurper re-acquired after this token's TTL expired.
|
||||
fake._store[_KEY] = "usurper-token"
|
||||
await mutex.release(token)
|
||||
assert fake._store.get(_KEY) == "usurper-token" # survives a stale release
|
||||
await mutex.release("usurper-token")
|
||||
assert _KEY not in fake._store # the owning token does clear it
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_heartbeat_once_true_when_owned_false_otherwise() -> None:
|
||||
fake = _FakeRedis()
|
||||
with patch("roboco.services.heartbeat_mutex.redis.from_url", return_value=fake):
|
||||
mutex = _mutex()
|
||||
token = await mutex.acquire()
|
||||
assert token is not None
|
||||
assert await mutex.heartbeat_once(token) is True
|
||||
assert await mutex.heartbeat_once("wrong-token") is False
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_acquire_raises_lock_unavailable_on_redis_error() -> None:
|
||||
broken = MagicMock()
|
||||
broken.set = AsyncMock(side_effect=ConnectionError("redis down"))
|
||||
broken.aclose = AsyncMock()
|
||||
with (
|
||||
patch("roboco.services.heartbeat_mutex.redis.from_url", return_value=broken),
|
||||
pytest.raises(HeartbeatLockUnavailable),
|
||||
):
|
||||
await _mutex().acquire()
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_run_guarded_returns_the_coroutine_result_on_success() -> None:
|
||||
async def _work() -> str:
|
||||
return "done"
|
||||
|
||||
mutex = _mutex(heartbeat=0.001)
|
||||
with patch.object(HeartbeatMutex, "heartbeat_once", AsyncMock(return_value=True)):
|
||||
result = await mutex.run_guarded(_work(), "tok")
|
||||
assert result.lock_lost is False
|
||||
assert result.value == "done"
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_run_guarded_renews_the_ttl_while_the_work_runs() -> None:
|
||||
calls = 0
|
||||
|
||||
async def _counting_heartbeat(_self: HeartbeatMutex, _token: str) -> bool:
|
||||
nonlocal calls
|
||||
calls += 1
|
||||
return True
|
||||
|
||||
async def _slow_work() -> str:
|
||||
await asyncio.sleep(0.02)
|
||||
return "done"
|
||||
|
||||
mutex = _mutex(heartbeat=0.001)
|
||||
with patch.object(HeartbeatMutex, "heartbeat_once", _counting_heartbeat):
|
||||
result = await mutex.run_guarded(_slow_work(), "tok")
|
||||
assert result.value == "done"
|
||||
assert calls >= 1 # at least one renew landed while the work was in flight
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_run_guarded_cancels_the_work_fail_closed_on_lock_loss() -> None:
|
||||
started = asyncio.Event()
|
||||
|
||||
async def _blocking_work() -> str:
|
||||
started.set()
|
||||
await asyncio.sleep(60)
|
||||
return "never"
|
||||
|
||||
mutex = _mutex(heartbeat=0.001)
|
||||
with patch.object(HeartbeatMutex, "heartbeat_once", AsyncMock(return_value=False)):
|
||||
result = await mutex.run_guarded(_blocking_work(), "tok")
|
||||
assert started.is_set() # the work did start, then got cancelled
|
||||
assert result.lock_lost is True
|
||||
assert result.value is None
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_run_guarded_tolerates_a_transient_renew_raise() -> None:
|
||||
"""One raised renew error, followed by recovery, must NOT trip
|
||||
lock_lost — the TTL is still alive so it's tolerated as a blip."""
|
||||
calls = 0
|
||||
|
||||
async def _flaky_heartbeat(_self: HeartbeatMutex, _token: str) -> bool:
|
||||
nonlocal calls
|
||||
calls += 1
|
||||
if calls == 1:
|
||||
raise ConnectionError("transient redis blip")
|
||||
return True
|
||||
|
||||
async def _work() -> str:
|
||||
await asyncio.sleep(0.02)
|
||||
return "done"
|
||||
|
||||
# ttl=60 vs. a sub-second test run: the grace window is enormous, so a
|
||||
# single raise is nowhere near "unable to renew for ~the whole TTL".
|
||||
mutex = _mutex(ttl=60, heartbeat=0.005)
|
||||
with patch.object(HeartbeatMutex, "heartbeat_once", _flaky_heartbeat):
|
||||
result = await mutex.run_guarded(_work(), "tok")
|
||||
assert result.lock_lost is False
|
||||
assert result.value == "done"
|
||||
assert calls >= _MIN_RENEWS_AFTER_RECOVERY
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_run_guarded_fails_closed_once_renew_errors_span_the_whole_ttl() -> None:
|
||||
"""A `heartbeat_once` that only ever RAISES (never returns falsy) must
|
||||
still fail closed once elapsed time since the last successful renew
|
||||
reaches ~the whole TTL — otherwise a holder stuck erroring on every
|
||||
renew would never learn its key expired server-side.
|
||||
|
||||
`heartbeat_seconds > ttl_seconds` collapses the grace window
|
||||
(`ttl_seconds - heartbeat_seconds`) to <= 0, so the very first raise's
|
||||
elapsed time (always >= 0) already exceeds it — deterministic, no
|
||||
reliance on real elapsed wall-clock time (and no monkeypatching
|
||||
`time.monotonic`, which is also asyncio's own scheduling clock).
|
||||
"""
|
||||
started = asyncio.Event()
|
||||
|
||||
async def _blocking_work() -> str:
|
||||
started.set()
|
||||
await asyncio.sleep(60)
|
||||
return "never"
|
||||
|
||||
mock_heartbeat = AsyncMock(side_effect=ConnectionError("redis down"))
|
||||
mutex = _mutex(ttl=1, heartbeat=2.0)
|
||||
with patch.object(HeartbeatMutex, "heartbeat_once", mock_heartbeat):
|
||||
result = await mutex.run_guarded(_blocking_work(), "tok")
|
||||
assert mock_heartbeat.call_count >= 1
|
||||
assert started.is_set()
|
||||
assert result.lock_lost is True
|
||||
assert result.value is None
|
||||
@@ -0,0 +1,200 @@
|
||||
"""The release-proposal publish hook drafts a video-authoring task
|
||||
(best-effort, never raises into approve()). Layering: release_proposal calls
|
||||
only the small typed seam ``VideoEngine.draft_release_video`` — this test
|
||||
patches at that seam, not the engine's internals. Mirrors
|
||||
test_release_proposal_x_hook.py for the sibling X-post hook."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from typing import TYPE_CHECKING, cast
|
||||
from unittest.mock import AsyncMock, patch
|
||||
from uuid import uuid4
|
||||
|
||||
import pytest
|
||||
from roboco.db.tables import AgentTable, ProjectTable, TaskTable
|
||||
from roboco.foundation import identity as _foundation
|
||||
from roboco.models.base import AgentRole, AgentStatus, TaskNature, TaskStatus, TaskType
|
||||
from roboco.models.base import Team as T
|
||||
from roboco.services.release_executor import ReleaseResult
|
||||
from roboco.services.release_proposal import ReleaseProposalService
|
||||
from roboco.services.release_readiness import ReleaseReadinessReport, report_to_dict
|
||||
from roboco.services.task import RELEASE_MANAGER_SOURCE
|
||||
|
||||
if TYPE_CHECKING:
|
||||
from uuid import UUID
|
||||
|
||||
from sqlalchemy.ext.asyncio import AsyncSession
|
||||
|
||||
_VERSION = "0.18.0"
|
||||
_CHANGELOG = f"## [{_VERSION}]\n\n### Added\n- a thing\n"
|
||||
|
||||
|
||||
def _report() -> ReleaseReadinessReport:
|
||||
return ReleaseReadinessReport(
|
||||
proposed_version=_VERSION,
|
||||
bump_kind="minor",
|
||||
change_summary=["feat: a thing", "fix: another thing"],
|
||||
drafted_changelog=_CHANGELOG,
|
||||
version_bump_plan=["pyproject.toml"],
|
||||
gaps=[],
|
||||
migration_notes=[],
|
||||
gate_state="green",
|
||||
)
|
||||
|
||||
|
||||
async def _seed_proposal(session: AsyncSession) -> TaskTable:
|
||||
system_uuid = _foundation.AGENTS["system"].uuid
|
||||
secretary_uuid = _foundation.AGENTS["secretary-1"].uuid
|
||||
for uuid_, slug, role in (
|
||||
(system_uuid, "system", AgentRole.SYSTEM),
|
||||
(secretary_uuid, "secretary-1", AgentRole.SECRETARY),
|
||||
):
|
||||
if await session.get(AgentTable, uuid_) is None:
|
||||
session.add(
|
||||
AgentTable(
|
||||
id=uuid_,
|
||||
name=slug,
|
||||
slug=slug,
|
||||
role=role,
|
||||
team=None,
|
||||
status=AgentStatus.ACTIVE,
|
||||
model_config={},
|
||||
system_prompt="x",
|
||||
capabilities=[],
|
||||
permissions={},
|
||||
metrics={},
|
||||
)
|
||||
)
|
||||
await session.flush()
|
||||
project = ProjectTable(
|
||||
id=uuid4(),
|
||||
name="RoboCo",
|
||||
slug=f"roboco-{uuid4().hex[:6]}",
|
||||
git_url="https://example.com/roboco.git",
|
||||
assigned_cell=T.BACKEND,
|
||||
created_by=system_uuid,
|
||||
)
|
||||
session.add(project)
|
||||
await session.flush()
|
||||
task = TaskTable(
|
||||
id=uuid4(),
|
||||
title=f"Release proposal: v{_VERSION}",
|
||||
description="proposal body",
|
||||
acceptance_criteria=["CEO approves"],
|
||||
status=TaskStatus.PENDING,
|
||||
priority=2,
|
||||
task_type=TaskType.ADMINISTRATIVE,
|
||||
nature=TaskNature.NON_TECHNICAL,
|
||||
project_id=project.id,
|
||||
created_by=system_uuid,
|
||||
assigned_to=secretary_uuid,
|
||||
team=T.MAIN_PM,
|
||||
source=RELEASE_MANAGER_SOURCE,
|
||||
confirmed_by_human=False,
|
||||
orchestration_markers={"release_report": report_to_dict(_report())},
|
||||
)
|
||||
session.add(task)
|
||||
await session.flush()
|
||||
return task
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_publish_success_calls_video_engine_draft_seam(
|
||||
db_session: AsyncSession,
|
||||
) -> None:
|
||||
task = await _seed_proposal(db_session)
|
||||
published = ReleaseResult(
|
||||
status="published",
|
||||
version=_VERSION,
|
||||
files_changed=["pyproject.toml"],
|
||||
commit_sha="abc123",
|
||||
release_url=f"https://github.com/x/roboco/releases/tag/v{_VERSION}",
|
||||
detail="ok",
|
||||
)
|
||||
fake_executor = AsyncMock()
|
||||
fake_executor.execute = AsyncMock(return_value=published)
|
||||
fake_x_engine = AsyncMock()
|
||||
fake_x_engine.draft_release_post = AsyncMock(return_value=None)
|
||||
fake_video_engine = AsyncMock()
|
||||
fake_video_engine.draft_release_video = AsyncMock(return_value=None)
|
||||
|
||||
with (
|
||||
patch(
|
||||
"roboco.services.release_proposal.get_release_executor",
|
||||
AsyncMock(return_value=fake_executor),
|
||||
),
|
||||
patch("roboco.services.x_engine.get_x_engine", return_value=fake_x_engine),
|
||||
patch(
|
||||
"roboco.services.video_engine.get_video_engine",
|
||||
return_value=fake_video_engine,
|
||||
),
|
||||
patch.object(
|
||||
ReleaseProposalService, "_acquire_release_lock", AsyncMock(return_value="t")
|
||||
),
|
||||
patch.object(
|
||||
ReleaseProposalService,
|
||||
"_release_release_lock",
|
||||
AsyncMock(return_value=None),
|
||||
),
|
||||
patch.object(
|
||||
ReleaseProposalService,
|
||||
"_heartbeat_release_lock",
|
||||
AsyncMock(return_value=True),
|
||||
),
|
||||
):
|
||||
result = await ReleaseProposalService(db_session).approve(cast("UUID", task.id))
|
||||
|
||||
assert result is not None
|
||||
assert result.status == "published"
|
||||
fake_video_engine.draft_release_video.assert_awaited_once_with(
|
||||
version=_VERSION, changelog=_CHANGELOG
|
||||
)
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_video_draft_failure_never_fails_the_approve(
|
||||
db_session: AsyncSession,
|
||||
) -> None:
|
||||
"""A drafting exception is swallowed — the release already published."""
|
||||
task = await _seed_proposal(db_session)
|
||||
published = ReleaseResult(
|
||||
status="published",
|
||||
version=_VERSION,
|
||||
files_changed=["pyproject.toml"],
|
||||
commit_sha="abc123",
|
||||
release_url=None,
|
||||
detail="ok",
|
||||
)
|
||||
fake_executor = AsyncMock()
|
||||
fake_executor.execute = AsyncMock(return_value=published)
|
||||
|
||||
with (
|
||||
patch(
|
||||
"roboco.services.release_proposal.get_release_executor",
|
||||
AsyncMock(return_value=fake_executor),
|
||||
),
|
||||
patch("roboco.services.x_engine.get_x_engine", return_value=AsyncMock()),
|
||||
patch(
|
||||
"roboco.services.video_engine.get_video_engine",
|
||||
side_effect=RuntimeError("video-engine boom"),
|
||||
),
|
||||
patch.object(
|
||||
ReleaseProposalService, "_acquire_release_lock", AsyncMock(return_value="t")
|
||||
),
|
||||
patch.object(
|
||||
ReleaseProposalService,
|
||||
"_release_release_lock",
|
||||
AsyncMock(return_value=None),
|
||||
),
|
||||
patch.object(
|
||||
ReleaseProposalService,
|
||||
"_heartbeat_release_lock",
|
||||
AsyncMock(return_value=True),
|
||||
),
|
||||
):
|
||||
result = await ReleaseProposalService(db_session).approve(cast("UUID", task.id))
|
||||
|
||||
assert result is not None
|
||||
assert result.status == "published"
|
||||
await db_session.refresh(task)
|
||||
assert task.status == TaskStatus.COMPLETED # the release itself still completed
|
||||
@@ -0,0 +1,168 @@
|
||||
"""RemotionRenderer coverage: tar/post/save happy path against a mocked httpx
|
||||
transport, plus unconfigured/unreachable graceful failure (never a crash).
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from pathlib import Path
|
||||
|
||||
import httpx
|
||||
import pytest
|
||||
from roboco.config import settings as cfg
|
||||
from roboco.services.remotion_client import (
|
||||
NullRemotionRenderer,
|
||||
RemotionRenderer,
|
||||
RemotionRendererError,
|
||||
get_remotion_renderer,
|
||||
)
|
||||
|
||||
|
||||
def _make_source(tmp_path: Path) -> Path:
|
||||
source = tmp_path / "motion"
|
||||
source.mkdir()
|
||||
(source / "Intro.tsx").write_text("export const Intro = () => null;")
|
||||
return source
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_render_posts_tar_and_saves_mp4(
|
||||
tmp_path: Path, monkeypatch: pytest.MonkeyPatch
|
||||
) -> None:
|
||||
source = _make_source(tmp_path)
|
||||
out_dir = tmp_path / "out"
|
||||
monkeypatch.setattr(cfg, "video_output_dir", str(out_dir))
|
||||
monkeypatch.setattr(cfg, "video_request_timeout_seconds", 5.0)
|
||||
monkeypatch.setattr(cfg, "video_render_timeout_seconds", 30.0)
|
||||
captured: dict[str, bytes | str] = {}
|
||||
|
||||
def handler(request: httpx.Request) -> httpx.Response:
|
||||
captured["url"] = str(request.url)
|
||||
captured["content_type"] = request.headers["content-type"]
|
||||
captured["body"] = request.content
|
||||
return httpx.Response(200, content=b"fake-mp4-bytes")
|
||||
|
||||
transport = httpx.MockTransport(handler)
|
||||
http_client = httpx.AsyncClient(transport=transport)
|
||||
renderer = RemotionRenderer(base_url="http://fake-remotion", client=http_client)
|
||||
|
||||
path = await renderer.render(
|
||||
source_dir=str(source),
|
||||
composition_id="Intro",
|
||||
input_props={"title": "hello"},
|
||||
orientation="vertical",
|
||||
render_key="task-99",
|
||||
)
|
||||
await http_client.aclose()
|
||||
|
||||
assert captured["url"] == "http://fake-remotion/render"
|
||||
assert str(captured["content_type"]).startswith("multipart/form-data")
|
||||
body = captured["body"]
|
||||
assert isinstance(body, bytes)
|
||||
assert b"composition_id" in body
|
||||
assert b"Intro" in body
|
||||
assert b"vertical" in body
|
||||
assert b"motion.tar.gz" in body
|
||||
assert b"\x1f\x8b" in body # gzip magic bytes: the tar payload made it in
|
||||
|
||||
saved = Path(path)
|
||||
assert saved.exists()
|
||||
assert saved.read_bytes() == b"fake-mp4-bytes"
|
||||
assert saved.parent == out_dir
|
||||
assert saved.name == "task-99-vertical.mp4" # task-scoped, not composition-scoped
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_render_non_success_response_raises_clear_error(
|
||||
tmp_path: Path, monkeypatch: pytest.MonkeyPatch
|
||||
) -> None:
|
||||
source = _make_source(tmp_path)
|
||||
monkeypatch.setattr(cfg, "video_output_dir", str(tmp_path / "out"))
|
||||
|
||||
def handler(_request: httpx.Request) -> httpx.Response:
|
||||
return httpx.Response(500, text="render crashed")
|
||||
|
||||
transport = httpx.MockTransport(handler)
|
||||
http_client = httpx.AsyncClient(transport=transport)
|
||||
renderer = RemotionRenderer(base_url="http://fake-remotion", client=http_client)
|
||||
|
||||
with pytest.raises(RemotionRendererError, match="500"):
|
||||
await renderer.render(
|
||||
source_dir=str(source),
|
||||
composition_id="Intro",
|
||||
input_props={},
|
||||
orientation="square",
|
||||
render_key="t1",
|
||||
)
|
||||
await http_client.aclose()
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_render_unreachable_sidecar_raises_clear_error(
|
||||
tmp_path: Path, monkeypatch: pytest.MonkeyPatch
|
||||
) -> None:
|
||||
source = _make_source(tmp_path)
|
||||
monkeypatch.setattr(cfg, "video_output_dir", str(tmp_path / "out"))
|
||||
|
||||
def handler(_request: httpx.Request) -> httpx.Response:
|
||||
raise httpx.ConnectError("connection refused")
|
||||
|
||||
transport = httpx.MockTransport(handler)
|
||||
http_client = httpx.AsyncClient(transport=transport)
|
||||
renderer = RemotionRenderer(base_url="http://fake-remotion", client=http_client)
|
||||
|
||||
with pytest.raises(RemotionRendererError, match="render request failed"):
|
||||
await renderer.render(
|
||||
source_dir=str(source),
|
||||
composition_id="Intro",
|
||||
input_props={},
|
||||
orientation="square",
|
||||
render_key="t1",
|
||||
)
|
||||
await http_client.aclose()
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_unconfigured_renderer_raises_without_network_call(
|
||||
tmp_path: Path,
|
||||
) -> None:
|
||||
source = _make_source(tmp_path)
|
||||
renderer = RemotionRenderer(base_url="")
|
||||
with pytest.raises(RemotionRendererError, match="not configured"):
|
||||
await renderer.render(
|
||||
source_dir=str(source),
|
||||
composition_id="Intro",
|
||||
input_props={},
|
||||
orientation="vertical",
|
||||
render_key="t1",
|
||||
)
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_null_renderer_raises_without_network_call(tmp_path: Path) -> None:
|
||||
source = _make_source(tmp_path)
|
||||
renderer = NullRemotionRenderer()
|
||||
with pytest.raises(RemotionRendererError, match="not configured"):
|
||||
await renderer.render(
|
||||
source_dir=str(source),
|
||||
composition_id="Intro",
|
||||
input_props={},
|
||||
orientation="vertical",
|
||||
render_key="t1",
|
||||
)
|
||||
|
||||
|
||||
def test_get_remotion_renderer_returns_null_when_unset(
|
||||
monkeypatch: pytest.MonkeyPatch,
|
||||
) -> None:
|
||||
monkeypatch.setattr(cfg, "remotion_base_url", "")
|
||||
renderer = get_remotion_renderer()
|
||||
assert isinstance(renderer, NullRemotionRenderer)
|
||||
|
||||
|
||||
def test_get_remotion_renderer_returns_real_client_when_set(
|
||||
monkeypatch: pytest.MonkeyPatch,
|
||||
) -> None:
|
||||
monkeypatch.setattr(cfg, "remotion_base_url", "http://roboco-remotion:3001")
|
||||
renderer = get_remotion_renderer()
|
||||
assert isinstance(renderer, RemotionRenderer)
|
||||
assert not isinstance(renderer, NullRemotionRenderer)
|
||||
@@ -0,0 +1,319 @@
|
||||
"""LiveTikTokPoster coverage: the inbox-upload sequence (init -> chunked PUT
|
||||
-> status poll), the asymmetric final chunk via `plan_chunk_ranges`, and the
|
||||
OAuth2 refresh-token rotation + persistence path.
|
||||
|
||||
Uses the real `db_session` fixture (mirrors test_video_post_service.py) since
|
||||
the refresh path genuinely persists to the `tiktok_credentials` row — a mock
|
||||
session can't stand in for that.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
from itertools import pairwise
|
||||
from typing import TYPE_CHECKING
|
||||
|
||||
import httpx
|
||||
import pytest
|
||||
from roboco.services.tiktok_client import (
|
||||
LiveTikTokPoster,
|
||||
build_tiktok_poster,
|
||||
plan_chunk_ranges,
|
||||
)
|
||||
from roboco.services.tiktok_credentials import (
|
||||
TikTokCredentialsData,
|
||||
get_tiktok_credentials_service,
|
||||
)
|
||||
from roboco.services.video_post_service import NullTikTokPoster
|
||||
|
||||
if TYPE_CHECKING:
|
||||
from pathlib import Path
|
||||
|
||||
from sqlalchemy.ext.asyncio import AsyncSession
|
||||
|
||||
TWO = 2
|
||||
FOUR = 4
|
||||
|
||||
_CREDS = TikTokCredentialsData(
|
||||
client_key="ck-test",
|
||||
client_secret="cs-test",
|
||||
access_token="at-test",
|
||||
refresh_token="rt-test",
|
||||
)
|
||||
|
||||
|
||||
# ---- plan_chunk_ranges (pure) ---------------------------------------------- #
|
||||
|
||||
|
||||
def test_plan_chunk_ranges_single_chunk_when_within_final_ceiling() -> None:
|
||||
assert plan_chunk_ranges(50, chunk_size=64, max_final_chunk=128) == [(0, 50)]
|
||||
|
||||
|
||||
def test_plan_chunk_ranges_folds_the_remainder_into_a_larger_final_chunk() -> None:
|
||||
"""Interior chunks stay a fixed size; the final one absorbs the
|
||||
remainder — larger than the interior size, the documented asymmetry."""
|
||||
ranges = plan_chunk_ranges(10, chunk_size=4, max_final_chunk=8)
|
||||
assert ranges == [(0, 4), (4, 10)]
|
||||
final_start, final_end = ranges[-1]
|
||||
assert (final_end - final_start) > FOUR # bigger than the interior chunk size
|
||||
|
||||
|
||||
def test_plan_chunk_ranges_multiple_interior_chunks() -> None:
|
||||
total = 300
|
||||
ranges = plan_chunk_ranges(total, chunk_size=64, max_final_chunk=128)
|
||||
assert ranges == [(0, 64), (64, 128), (128, 192), (192, 300)]
|
||||
assert sum(end - start for start, end in ranges) == total
|
||||
|
||||
|
||||
def test_plan_chunk_ranges_is_contiguous_with_no_gaps_or_overlaps() -> None:
|
||||
total = 1000
|
||||
ranges = plan_chunk_ranges(total, chunk_size=97, max_final_chunk=150)
|
||||
assert ranges[0][0] == 0
|
||||
assert ranges[-1][1] == total
|
||||
for (_, prev_end), (next_start, _) in pairwise(ranges):
|
||||
assert prev_end == next_start
|
||||
|
||||
|
||||
def test_plan_chunk_ranges_empty_file() -> None:
|
||||
assert plan_chunk_ranges(0, chunk_size=64, max_final_chunk=128) == [(0, 0)]
|
||||
|
||||
|
||||
# ---- build_tiktok_poster branching ----------------------------------------- #
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_build_without_creds_returns_null(db_session: AsyncSession) -> None:
|
||||
poster = build_tiktok_poster(None, session=db_session, timeout=5.0)
|
||||
assert isinstance(poster, NullTikTokPoster)
|
||||
assert poster.configured is False
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_build_with_creds_returns_live(db_session: AsyncSession) -> None:
|
||||
poster = build_tiktok_poster(_CREDS, session=db_session, timeout=5.0)
|
||||
assert isinstance(poster, LiveTikTokPoster)
|
||||
assert poster.configured is True
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_null_poster_upload_is_a_noop() -> None:
|
||||
result = await NullTikTokPoster().upload_to_inbox(
|
||||
mp4_path="/tmp/x.mp4", caption="hi"
|
||||
)
|
||||
assert result.uploaded is False
|
||||
assert result.publish_id is None
|
||||
|
||||
|
||||
def _write_clip(tmp_path: Path, data: bytes) -> str:
|
||||
mp4 = tmp_path / "clip.mp4"
|
||||
mp4.write_bytes(data)
|
||||
return str(mp4)
|
||||
|
||||
|
||||
async def _no_sleep(_seconds: float) -> None:
|
||||
return None
|
||||
|
||||
|
||||
# ---- upload_to_inbox: full sequence + asymmetric chunk over the wire ------- #
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_upload_to_inbox_full_sequence_with_asymmetric_last_chunk(
|
||||
tmp_path: Path, monkeypatch: pytest.MonkeyPatch, db_session: AsyncSession
|
||||
) -> None:
|
||||
monkeypatch.setattr("roboco.services.tiktok_client._CHUNK_SIZE_BYTES", 4)
|
||||
monkeypatch.setattr("roboco.services.tiktok_client._MAX_FINAL_CHUNK_BYTES", 8)
|
||||
monkeypatch.setattr("roboco.services.tiktok_client.asyncio.sleep", _no_sleep)
|
||||
|
||||
put_ranges: list[str] = []
|
||||
status_calls = {"count": 0}
|
||||
|
||||
def handler(request: httpx.Request) -> httpx.Response:
|
||||
path = request.url.path
|
||||
if request.method == "POST" and path.endswith("/inbox/video/init/"):
|
||||
assert request.headers["Authorization"] == "Bearer at-test"
|
||||
body = json.loads(request.content)["source_info"]
|
||||
assert body == {
|
||||
"source": "FILE_UPLOAD",
|
||||
"video_size": 10,
|
||||
"chunk_size": 4,
|
||||
"total_chunk_count": TWO,
|
||||
}
|
||||
return httpx.Response(
|
||||
200,
|
||||
json={
|
||||
"data": {
|
||||
"publish_id": "pub1",
|
||||
"upload_url": "https://upload.tiktokapis.com/put/pub1",
|
||||
}
|
||||
},
|
||||
)
|
||||
if request.method == "PUT":
|
||||
put_ranges.append(request.headers["Content-Range"])
|
||||
assert request.headers["Content-Type"] == "video/mp4"
|
||||
return httpx.Response(200)
|
||||
if request.method == "POST" and path.endswith("/status/fetch/"):
|
||||
status_calls["count"] += 1
|
||||
state = (
|
||||
"PROCESSING_UPLOAD"
|
||||
if status_calls["count"] == 1
|
||||
else "SEND_TO_USER_INBOX"
|
||||
)
|
||||
return httpx.Response(200, json={"data": {"status": state}})
|
||||
raise AssertionError(f"unexpected request {request.method} {path}")
|
||||
|
||||
transport = httpx.MockTransport(handler)
|
||||
http_client = httpx.AsyncClient(transport=transport)
|
||||
poster = LiveTikTokPoster(
|
||||
_CREDS, session=db_session, timeout=5.0, client=http_client
|
||||
)
|
||||
result = await poster.upload_to_inbox(
|
||||
mp4_path=_write_clip(tmp_path, b"0123456789"), caption="ignored by inbox mode"
|
||||
)
|
||||
await http_client.aclose()
|
||||
|
||||
assert result.uploaded is True
|
||||
assert result.publish_id == "pub1"
|
||||
# Interior chunk is 4 bytes; the final chunk absorbs the remainder (6
|
||||
# bytes) rather than being sent as its own small trailing chunk.
|
||||
assert put_ranges == ["bytes 0-3/10", "bytes 4-9/10"]
|
||||
assert status_calls["count"] == TWO # PROCESSING_UPLOAD once, then terminal
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_upload_publish_failed_status_is_graceful(
|
||||
tmp_path: Path, monkeypatch: pytest.MonkeyPatch, db_session: AsyncSession
|
||||
) -> None:
|
||||
monkeypatch.setattr("roboco.services.tiktok_client.asyncio.sleep", _no_sleep)
|
||||
|
||||
def handler(request: httpx.Request) -> httpx.Response:
|
||||
path = request.url.path
|
||||
if path.endswith("/inbox/video/init/"):
|
||||
return httpx.Response(
|
||||
200, json={"data": {"publish_id": "pub1", "upload_url": "https://u/x"}}
|
||||
)
|
||||
if request.method == "PUT":
|
||||
return httpx.Response(200)
|
||||
if path.endswith("/status/fetch/"):
|
||||
return httpx.Response(200, json={"data": {"status": "FAILED"}})
|
||||
raise AssertionError(f"unexpected request {path}")
|
||||
|
||||
transport = httpx.MockTransport(handler)
|
||||
http_client = httpx.AsyncClient(transport=transport)
|
||||
poster = LiveTikTokPoster(
|
||||
_CREDS, session=db_session, timeout=5.0, client=http_client
|
||||
)
|
||||
result = await poster.upload_to_inbox(
|
||||
mp4_path=_write_clip(tmp_path, b"short"), caption="x"
|
||||
)
|
||||
await http_client.aclose()
|
||||
|
||||
assert result.uploaded is False
|
||||
assert result.publish_id is None
|
||||
assert "publish failed" in result.detail
|
||||
|
||||
|
||||
# ---- OAuth2 refresh: rotate + persist -------------------------------------- #
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_upload_refreshes_and_persists_rotated_token_on_401(
|
||||
tmp_path: Path, db_session: AsyncSession
|
||||
) -> None:
|
||||
"""A 401 on the Bearer-authed init call triggers one refresh + retry; the
|
||||
rotated access/refresh token pair must land in the DB row — not just be
|
||||
held in the poster's in-memory creds."""
|
||||
await get_tiktok_credentials_service(db_session).set_credentials(
|
||||
client_key=_CREDS.client_key,
|
||||
client_secret=_CREDS.client_secret,
|
||||
access_token=_CREDS.access_token,
|
||||
refresh_token=_CREDS.refresh_token,
|
||||
)
|
||||
init_auth_headers: list[str] = []
|
||||
|
||||
def handler(request: httpx.Request) -> httpx.Response:
|
||||
path = request.url.path
|
||||
if path.endswith("/oauth/token/"):
|
||||
form = dict(httpx.QueryParams(request.content.decode()))
|
||||
assert form["grant_type"] == "refresh_token"
|
||||
assert form["refresh_token"] == "rt-test"
|
||||
return httpx.Response(
|
||||
200, json={"access_token": "at-rotated", "refresh_token": "rt-rotated"}
|
||||
)
|
||||
if path.endswith("/inbox/video/init/"):
|
||||
init_auth_headers.append(request.headers["Authorization"])
|
||||
if request.headers["Authorization"] == "Bearer at-test":
|
||||
return httpx.Response(401, json={"error": "access_token_invalid"})
|
||||
return httpx.Response(
|
||||
200, json={"data": {"publish_id": "pub2", "upload_url": "https://u/x"}}
|
||||
)
|
||||
if request.method == "PUT":
|
||||
return httpx.Response(200)
|
||||
if path.endswith("/status/fetch/"):
|
||||
return httpx.Response(200, json={"data": {"status": "SEND_TO_USER_INBOX"}})
|
||||
raise AssertionError(f"unexpected request {path}")
|
||||
|
||||
transport = httpx.MockTransport(handler)
|
||||
http_client = httpx.AsyncClient(transport=transport)
|
||||
poster = LiveTikTokPoster(
|
||||
_CREDS, session=db_session, timeout=5.0, client=http_client
|
||||
)
|
||||
result = await poster.upload_to_inbox(
|
||||
mp4_path=_write_clip(tmp_path, b"short"), caption="x"
|
||||
)
|
||||
await http_client.aclose()
|
||||
|
||||
assert result.uploaded is True
|
||||
assert init_auth_headers == ["Bearer at-test", "Bearer at-rotated"]
|
||||
|
||||
stored = await get_tiktok_credentials_service(db_session).get_decrypted()
|
||||
assert stored is not None
|
||||
assert stored.access_token == "at-rotated"
|
||||
assert stored.refresh_token == "rt-rotated"
|
||||
assert stored.client_key == _CREDS.client_key # untouched by the refresh
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_refresh_falls_back_to_current_refresh_token_when_response_omits_it(
|
||||
tmp_path: Path, db_session: AsyncSession
|
||||
) -> None:
|
||||
"""TikTok doesn't always rotate the refresh_token — when the grant
|
||||
response omits it, the previous one must be kept, not nulled out."""
|
||||
await get_tiktok_credentials_service(db_session).set_credentials(
|
||||
client_key=_CREDS.client_key,
|
||||
client_secret=_CREDS.client_secret,
|
||||
access_token=_CREDS.access_token,
|
||||
refresh_token=_CREDS.refresh_token,
|
||||
)
|
||||
|
||||
def handler(request: httpx.Request) -> httpx.Response:
|
||||
path = request.url.path
|
||||
if path.endswith("/oauth/token/"):
|
||||
return httpx.Response(200, json={"access_token": "at-rotated"})
|
||||
if path.endswith("/inbox/video/init/"):
|
||||
if request.headers["Authorization"] == "Bearer at-test":
|
||||
return httpx.Response(401, json={"error": "access_token_invalid"})
|
||||
return httpx.Response(
|
||||
200, json={"data": {"publish_id": "pub3", "upload_url": "https://u/x"}}
|
||||
)
|
||||
if request.method == "PUT":
|
||||
return httpx.Response(200)
|
||||
if path.endswith("/status/fetch/"):
|
||||
return httpx.Response(200, json={"data": {"status": "SEND_TO_USER_INBOX"}})
|
||||
raise AssertionError(f"unexpected request {path}")
|
||||
|
||||
transport = httpx.MockTransport(handler)
|
||||
http_client = httpx.AsyncClient(transport=transport)
|
||||
poster = LiveTikTokPoster(
|
||||
_CREDS, session=db_session, timeout=5.0, client=http_client
|
||||
)
|
||||
result = await poster.upload_to_inbox(
|
||||
mp4_path=_write_clip(tmp_path, b"x"), caption="x"
|
||||
)
|
||||
await http_client.aclose()
|
||||
|
||||
assert result.uploaded is True
|
||||
stored = await get_tiktok_credentials_service(db_session).get_decrypted()
|
||||
assert stored is not None
|
||||
assert stored.access_token == "at-rotated"
|
||||
assert stored.refresh_token == _CREDS.refresh_token # unchanged, fallback
|
||||
@@ -0,0 +1,462 @@
|
||||
"""VideoEngine coverage: authoring-task origination + held-draft materialization.
|
||||
|
||||
Mirrors the X-engine tests: flag-gated, dedup, rolling open-cap, and a
|
||||
deterministic ux-dev balance. The authoring task (source=video) is a normal
|
||||
ASSIGNED delivery task — never held; the post draft (source=video_post) is
|
||||
Secretary-owned and held for the CEO. Asserted against a real Postgres DB.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from typing import TYPE_CHECKING
|
||||
from unittest.mock import AsyncMock
|
||||
|
||||
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, Complexity, Team
|
||||
from roboco.models.base import TaskStatus as TS
|
||||
from roboco.services import video_engine as video_engine_module
|
||||
from roboco.services.task import VIDEO_POST_SOURCE, VIDEO_SOURCE, get_task_service
|
||||
from sqlalchemy import delete, 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
|
||||
|
||||
|
||||
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)
|
||||
for key, value in overrides.items():
|
||||
monkeypatch.setattr(cfg, key, value)
|
||||
|
||||
|
||||
def _mock_local_model(monkeypatch: pytest.MonkeyPatch, reply: str | None) -> AsyncMock:
|
||||
mock = AsyncMock(return_value=reply)
|
||||
monkeypatch.setattr(video_engine_module, "_chat", mock)
|
||||
return mock
|
||||
|
||||
|
||||
# --------------------------------------------------------------------------- #
|
||||
# open_video_task
|
||||
# --------------------------------------------------------------------------- #
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_disabled_opens_no_video_task(
|
||||
db_session: AsyncSession, monkeypatch: pytest.MonkeyPatch
|
||||
) -> None:
|
||||
await _seed(db_session)
|
||||
monkeypatch.setattr(cfg, "video_engine_enabled", False)
|
||||
engine = video_engine_module.VideoEngine(db_session)
|
||||
task = await engine.open_video_task(
|
||||
occasion="release v1.0.0", script="script", platforms=["x"], brief="brief"
|
||||
)
|
||||
assert task is None
|
||||
assert await get_task_service(db_session).list_open_video_posts() == []
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_open_video_task_creates_assigned_authoring_task(
|
||||
db_session: AsyncSession, monkeypatch: pytest.MonkeyPatch
|
||||
) -> None:
|
||||
await _seed(db_session)
|
||||
_enable(monkeypatch)
|
||||
engine = video_engine_module.VideoEngine(db_session)
|
||||
task = await engine.open_video_task(
|
||||
occasion="release v1.0.0",
|
||||
script="Here's what shipped",
|
||||
platforms=["x", "tiktok"],
|
||||
brief="Announce the release",
|
||||
)
|
||||
assert task is not None
|
||||
assert task.team == Team.UX_UI
|
||||
assert task.assigned_to == UX_DEV_1_UUID # deterministic first pick
|
||||
assert task.source == VIDEO_SOURCE
|
||||
assert task.status == TS.PENDING
|
||||
assert task.confirmed_by_human is True # normal delivery task, not CEO-held
|
||||
# LOW so it clears _check_dev_needs_subtasks; a medium/high root dev task
|
||||
# would auto-block for subtasks it never owns and deadlock.
|
||||
assert task.estimated_complexity == Complexity.LOW
|
||||
assert task.acceptance_criteria # non-empty
|
||||
project = await db_session.get(ProjectTable, task.project_id)
|
||||
assert project is not None
|
||||
assert project.slug == SLUG
|
||||
draft = markers.get_video_draft(task)
|
||||
assert draft is not None
|
||||
assert draft["occasion"] == "release v1.0.0"
|
||||
assert draft["script"] == "Here's what shipped"
|
||||
assert draft["platforms"] == ["x", "tiktok"]
|
||||
assert draft["brief"] == "Announce the release"
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_open_video_task_balances_across_ux_devs(
|
||||
db_session: AsyncSession, monkeypatch: pytest.MonkeyPatch
|
||||
) -> None:
|
||||
await _seed(db_session)
|
||||
_enable(monkeypatch)
|
||||
engine = video_engine_module.VideoEngine(db_session)
|
||||
first = await engine.open_video_task(
|
||||
occasion="release v1.0.0", script="s", platforms=["x"], brief="b"
|
||||
)
|
||||
second = await engine.open_video_task(
|
||||
occasion="release v2.0.0", script="s", platforms=["x"], brief="b"
|
||||
)
|
||||
assert first is not None
|
||||
assert second is not None
|
||||
assert first.assigned_to == UX_DEV_1_UUID
|
||||
assert second.assigned_to == UX_DEV_2_UUID # balanced onto the less-loaded dev
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_open_video_task_dedupes_same_occasion(
|
||||
db_session: AsyncSession, monkeypatch: pytest.MonkeyPatch
|
||||
) -> None:
|
||||
await _seed(db_session)
|
||||
_enable(monkeypatch)
|
||||
engine = video_engine_module.VideoEngine(db_session)
|
||||
await engine.open_video_task(
|
||||
occasion="release v1.0.0", script="s", platforms=["x"], brief="b"
|
||||
)
|
||||
second = await engine.open_video_task(
|
||||
occasion="release v1.0.0", script="s2", platforms=["x"], brief="b2"
|
||||
)
|
||||
assert second is None
|
||||
open_tasks = await get_task_service(db_session).list_open_video_posts()
|
||||
assert len(open_tasks) == ONE
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_open_video_task_respects_open_cap(
|
||||
db_session: AsyncSession, monkeypatch: pytest.MonkeyPatch
|
||||
) -> None:
|
||||
await _seed(db_session)
|
||||
_enable(monkeypatch, video_max_open_posts=1)
|
||||
engine = video_engine_module.VideoEngine(db_session)
|
||||
await engine.open_video_task(
|
||||
occasion="release v1.0.0", script="s", platforms=["x"], brief="b"
|
||||
)
|
||||
second = await engine.open_video_task(
|
||||
occasion="release v2.0.0", script="s", platforms=["x"], brief="b"
|
||||
)
|
||||
assert second is None
|
||||
open_tasks = await get_task_service(db_session).list_open_video_posts()
|
||||
assert len(open_tasks) == ONE
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_open_video_task_unresolvable_project_opens_nothing(
|
||||
db_session: AsyncSession, monkeypatch: pytest.MonkeyPatch
|
||||
) -> None:
|
||||
await _seed(db_session)
|
||||
_enable(monkeypatch)
|
||||
monkeypatch.setattr(cfg, "self_heal_project_slug", "no-such-project")
|
||||
engine = video_engine_module.VideoEngine(db_session)
|
||||
task = await engine.open_video_task(
|
||||
occasion="release v1.0.0", script="s", platforms=["x"], brief="b"
|
||||
)
|
||||
assert task is None
|
||||
assert await get_task_service(db_session).list_open_video_posts() == []
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_open_video_task_insert_error_returns_none_session_usable(
|
||||
db_session: AsyncSession, monkeypatch: pytest.MonkeyPatch
|
||||
) -> None:
|
||||
"""F042 guard: a real DBAPI error on the authoring insert (assignee FK
|
||||
absent) rolls back ONLY the savepoint and returns None; the shared session
|
||||
stays usable, so a caller's later commit is not poisoned."""
|
||||
if await db_session.get(AgentTable, SYSTEM_UUID) is None:
|
||||
db_session.add(
|
||||
AgentTable(
|
||||
id=SYSTEM_UUID,
|
||||
name="system",
|
||||
slug="system",
|
||||
role=AgentRole.SYSTEM,
|
||||
team=None,
|
||||
status=AgentStatus.ACTIVE,
|
||||
model_config={},
|
||||
system_prompt="x",
|
||||
capabilities=[],
|
||||
permissions={},
|
||||
metrics={},
|
||||
)
|
||||
)
|
||||
# ux-devs deliberately absent -> the assigned_to FK violates at flush.
|
||||
await db_session.execute(
|
||||
delete(AgentTable).where(AgentTable.id.in_([UX_DEV_1_UUID, UX_DEV_2_UUID]))
|
||||
)
|
||||
has_project = (
|
||||
await db_session.execute(select(ProjectTable).where(ProjectTable.slug == SLUG))
|
||||
).scalar_one_or_none()
|
||||
if has_project is None:
|
||||
db_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 db_session.flush()
|
||||
_enable(monkeypatch)
|
||||
engine = video_engine_module.VideoEngine(db_session)
|
||||
task = await engine.open_video_task(
|
||||
occasion="fk-fail", script="s", platforms=["x"], brief="b"
|
||||
)
|
||||
assert task is None
|
||||
# Not poisoned: a follow-up statement runs cleanly (this raised
|
||||
# PendingRollbackError before the savepoint fix).
|
||||
check = await db_session.execute(
|
||||
select(ProjectTable).where(ProjectTable.slug == SLUG)
|
||||
)
|
||||
assert check.scalar_one_or_none() is not None
|
||||
|
||||
|
||||
# --------------------------------------------------------------------------- #
|
||||
# _originate_video_post
|
||||
# --------------------------------------------------------------------------- #
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_originate_video_post_holds_draft_for_secretary(
|
||||
db_session: AsyncSession, monkeypatch: pytest.MonkeyPatch
|
||||
) -> None:
|
||||
await _seed(db_session)
|
||||
_enable(monkeypatch)
|
||||
engine = video_engine_module.VideoEngine(db_session)
|
||||
source_task = await engine.open_video_task(
|
||||
occasion="release v1.0.0",
|
||||
script="Here's what shipped",
|
||||
platforms=["x", "tiktok"],
|
||||
brief="Announce the release",
|
||||
)
|
||||
assert source_task is not None
|
||||
|
||||
draft_task = await engine._originate_video_post(
|
||||
source_task=source_task,
|
||||
mp4_paths={
|
||||
"vertical": "/render/out/a-vertical.mp4",
|
||||
"square": "/render/out/a-square.mp4",
|
||||
},
|
||||
captions={
|
||||
"x": "We just shipped v1.0.0!",
|
||||
"tiktok": "New release, check it out",
|
||||
},
|
||||
platforms=["x", "tiktok"],
|
||||
)
|
||||
|
||||
assert draft_task.team == Team.MAIN_PM
|
||||
assert draft_task.assigned_to == SECRETARY_UUID
|
||||
assert draft_task.source == VIDEO_POST_SOURCE
|
||||
assert draft_task.status == TS.PENDING
|
||||
assert draft_task.confirmed_by_human is False # HELD; never dispatched
|
||||
|
||||
draft = markers.get_video_draft(draft_task)
|
||||
assert draft is not None
|
||||
assert draft["occasion"] == "release v1.0.0" # carried forward from the source
|
||||
assert draft["script"] == "Here's what shipped"
|
||||
assert draft["mp4_paths"] == {
|
||||
"vertical": "/render/out/a-vertical.mp4",
|
||||
"square": "/render/out/a-square.mp4",
|
||||
}
|
||||
assert draft["x_caption"] == "We just shipped v1.0.0!"
|
||||
assert draft["tiktok_caption"] == "New release, check it out"
|
||||
assert draft["platforms"] == ["x", "tiktok"]
|
||||
assert draft["render_status"] == "rendered"
|
||||
assert draft["source_task_id"] == str(source_task.id) # traceability back-ref
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_originate_video_post_not_counted_by_dedupe_against_new_occasion(
|
||||
db_session: AsyncSession, monkeypatch: pytest.MonkeyPatch
|
||||
) -> None:
|
||||
"""A materialized post draft still occupies the shared open-cap/dedupe
|
||||
pool (list_open_video_posts spans both sources) — a fresh occasion is
|
||||
unaffected, but the cap still counts it."""
|
||||
await _seed(db_session)
|
||||
_enable(monkeypatch, video_max_open_posts=2)
|
||||
engine = video_engine_module.VideoEngine(db_session)
|
||||
source_task = await engine.open_video_task(
|
||||
occasion="release v1.0.0", script="s", platforms=["x"], brief="b"
|
||||
)
|
||||
assert source_task is not None
|
||||
source_task.status = TS.COMPLETED
|
||||
await db_session.flush()
|
||||
await engine._originate_video_post(
|
||||
source_task=source_task,
|
||||
mp4_paths={"vertical": "a.mp4", "square": "b.mp4"},
|
||||
captions={"x": "caption"},
|
||||
platforms=["x"],
|
||||
)
|
||||
# One open (the held draft; the source authoring task is now COMPLETED and
|
||||
# therefore excluded) plus room for exactly one more before the cap bites.
|
||||
open_tasks = await get_task_service(db_session).list_open_video_posts()
|
||||
assert len(open_tasks) == ONE
|
||||
|
||||
second = await engine.open_video_task(
|
||||
occasion="release v2.0.0", script="s", platforms=["x"], brief="b"
|
||||
)
|
||||
assert second is not None
|
||||
open_tasks = await get_task_service(db_session).list_open_video_posts()
|
||||
assert len(open_tasks) == TWO
|
||||
|
||||
|
||||
# --------------------------------------------------------------------------- #
|
||||
# draft_release_video
|
||||
# --------------------------------------------------------------------------- #
|
||||
|
||||
_CHANGELOG = "## [1.0.0]\n\n### Added\n- a huge new release\n"
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_draft_release_video_disabled_opens_nothing(
|
||||
db_session: AsyncSession, monkeypatch: pytest.MonkeyPatch
|
||||
) -> None:
|
||||
await _seed(db_session)
|
||||
_enable(monkeypatch, video_on_release=True)
|
||||
monkeypatch.setattr(cfg, "video_engine_enabled", False)
|
||||
engine = video_engine_module.VideoEngine(db_session)
|
||||
task = await engine.draft_release_video(version="1.0.0", changelog=_CHANGELOG)
|
||||
assert task is None
|
||||
assert await get_task_service(db_session).list_open_video_posts() == []
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_draft_release_video_sub_switch_off_opens_nothing(
|
||||
db_session: AsyncSession, monkeypatch: pytest.MonkeyPatch
|
||||
) -> None:
|
||||
await _seed(db_session)
|
||||
_enable(monkeypatch, video_on_release=False)
|
||||
engine = video_engine_module.VideoEngine(db_session)
|
||||
task = await engine.draft_release_video(version="1.0.0", changelog=_CHANGELOG)
|
||||
assert task is None
|
||||
assert await get_task_service(db_session).list_open_video_posts() == []
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_draft_release_video_opens_authoring_task(
|
||||
db_session: AsyncSession, monkeypatch: pytest.MonkeyPatch
|
||||
) -> None:
|
||||
await _seed(db_session)
|
||||
_enable(monkeypatch, video_on_release=True)
|
||||
_mock_local_model(monkeypatch, "RoboCo v1.0.0 just shipped a huge release.")
|
||||
engine = video_engine_module.VideoEngine(db_session)
|
||||
task = await engine.draft_release_video(version="1.0.0", changelog=_CHANGELOG)
|
||||
assert task is not None
|
||||
assert task.source == VIDEO_SOURCE
|
||||
assert task.team == Team.UX_UI
|
||||
assert task.confirmed_by_human is True
|
||||
draft = markers.get_video_draft(task)
|
||||
assert draft is not None
|
||||
assert draft["occasion"] == "release 1.0.0"
|
||||
assert draft["platforms"] == ["x", "tiktok"]
|
||||
assert draft["script"] == "RoboCo v1.0.0 just shipped a huge release."
|
||||
assert draft["brief"] == draft["script"]
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_draft_release_video_falls_back_to_template_on_local_model_failure(
|
||||
db_session: AsyncSession, monkeypatch: pytest.MonkeyPatch
|
||||
) -> None:
|
||||
await _seed(db_session)
|
||||
_enable(monkeypatch, video_on_release=True)
|
||||
mock = AsyncMock(side_effect=RuntimeError("ollama down"))
|
||||
monkeypatch.setattr(video_engine_module, "_chat", mock)
|
||||
engine = video_engine_module.VideoEngine(db_session)
|
||||
task = await engine.draft_release_video(version="1.0.0", changelog=_CHANGELOG)
|
||||
assert task is not None
|
||||
draft = markers.get_video_draft(task)
|
||||
assert draft is not None
|
||||
assert "1.0.0" in draft["script"]
|
||||
assert "a huge new release" in draft["script"]
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_draft_release_video_falls_back_to_template_on_empty_local_reply(
|
||||
db_session: AsyncSession, monkeypatch: pytest.MonkeyPatch
|
||||
) -> None:
|
||||
await _seed(db_session)
|
||||
_enable(monkeypatch, video_on_release=True)
|
||||
_mock_local_model(monkeypatch, None) # non-success / empty local-model reply
|
||||
engine = video_engine_module.VideoEngine(db_session)
|
||||
task = await engine.draft_release_video(version="2.0.0", changelog="- no bullets")
|
||||
assert task is not None
|
||||
draft = markers.get_video_draft(task)
|
||||
assert draft is not None
|
||||
assert draft["script"] == "RoboCo v2.0.0 just shipped: no bullets."
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_draft_release_video_dedupes_same_version(
|
||||
db_session: AsyncSession, monkeypatch: pytest.MonkeyPatch
|
||||
) -> None:
|
||||
await _seed(db_session)
|
||||
_enable(monkeypatch, video_on_release=True)
|
||||
_mock_local_model(monkeypatch, "shipped!")
|
||||
engine = video_engine_module.VideoEngine(db_session)
|
||||
first = await engine.draft_release_video(version="1.0.0", changelog=_CHANGELOG)
|
||||
second = await engine.draft_release_video(version="1.0.0", changelog=_CHANGELOG)
|
||||
assert first is not None
|
||||
assert second is None
|
||||
open_tasks = await get_task_service(db_session).list_open_video_posts()
|
||||
assert len(open_tasks) == ONE
|
||||
@@ -0,0 +1,752 @@
|
||||
"""VideoPostService coverage: approve posts per-platform (idempotent), reject
|
||||
cancels.
|
||||
|
||||
Mirrors the X-post service tests. The heartbeat-mutex acquire/release are
|
||||
patched (no live Redis in tests, matching the project's `_no_live_redis`
|
||||
fixture) so approve exercises the real per-platform dispatch + status-
|
||||
transition path; the run_guarded renew loop is left unpatched — its heartbeat
|
||||
calls fail fast against the poisoned test Redis and are swallowed exactly as
|
||||
in production, so no separate mock is needed there.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import asyncio
|
||||
import contextlib
|
||||
from typing import TYPE_CHECKING, cast
|
||||
from unittest.mock import AsyncMock, MagicMock, patch
|
||||
from uuid import uuid4
|
||||
|
||||
import pytest
|
||||
from roboco.db.tables import AgentTable, ProjectTable, TaskTable
|
||||
from roboco.foundation import identity as _foundation
|
||||
from roboco.foundation.policy.content import markers
|
||||
from roboco.models.base import (
|
||||
AgentRole,
|
||||
AgentStatus,
|
||||
Complexity,
|
||||
Team,
|
||||
)
|
||||
from roboco.models.base import TaskNature as TN
|
||||
from roboco.models.base import TaskStatus as TS
|
||||
from roboco.models.base import TaskType as TT
|
||||
from roboco.services.heartbeat_mutex import HeartbeatMutex
|
||||
from roboco.services.task import VIDEO_POST_SOURCE, TaskService
|
||||
from roboco.services.video_post_service import (
|
||||
TikTokPoster,
|
||||
TikTokUploadResult,
|
||||
VideoCaptionTooLongError,
|
||||
VideoPostService,
|
||||
XVideoPoster,
|
||||
XVideoPostResult,
|
||||
get_video_post_service,
|
||||
)
|
||||
from sqlalchemy import delete
|
||||
from sqlalchemy.ext.asyncio import (
|
||||
AsyncEngine,
|
||||
AsyncSession,
|
||||
async_sessionmaker,
|
||||
create_async_engine,
|
||||
)
|
||||
|
||||
if TYPE_CHECKING:
|
||||
from uuid import UUID
|
||||
|
||||
SYSTEM_UUID = _foundation.AGENTS["system"].uuid
|
||||
SECRETARY_UUID = _foundation.AGENTS["secretary-1"].uuid
|
||||
TWO = 2
|
||||
VERTICAL_MP4 = "/render/out/1-vertical.mp4"
|
||||
SQUARE_MP4 = "/render/out/1-square.mp4"
|
||||
|
||||
|
||||
class _StubXPoster(XVideoPoster):
|
||||
def __init__(
|
||||
self,
|
||||
*,
|
||||
posted: bool = True,
|
||||
video_id: str = "x-vid-1",
|
||||
raises: bool = False,
|
||||
) -> None:
|
||||
self._posted = posted
|
||||
self._video_id = video_id
|
||||
self._raises = raises
|
||||
self.calls: list[tuple[str, str]] = []
|
||||
|
||||
@property
|
||||
def configured(self) -> bool:
|
||||
return True
|
||||
|
||||
async def post_video(self, *, mp4_path: str, caption: str) -> XVideoPostResult:
|
||||
self.calls.append((mp4_path, caption))
|
||||
if self._raises:
|
||||
raise RuntimeError("simulated X network failure")
|
||||
if not self._posted:
|
||||
return XVideoPostResult(posted=False, video_id=None, detail="rejected by X")
|
||||
return XVideoPostResult(posted=True, video_id=self._video_id, detail="posted")
|
||||
|
||||
|
||||
class _StubTikTokPoster(TikTokPoster):
|
||||
def __init__(
|
||||
self,
|
||||
*,
|
||||
uploaded: bool = True,
|
||||
publish_id: str = "tt-pub-1",
|
||||
raises: bool = False,
|
||||
) -> None:
|
||||
self._uploaded = uploaded
|
||||
self._publish_id = publish_id
|
||||
self._raises = raises
|
||||
self.calls: list[tuple[str, str]] = []
|
||||
|
||||
@property
|
||||
def configured(self) -> bool:
|
||||
return True
|
||||
|
||||
async def upload_to_inbox(
|
||||
self, *, mp4_path: str, caption: str
|
||||
) -> TikTokUploadResult:
|
||||
self.calls.append((mp4_path, caption))
|
||||
if self._raises:
|
||||
raise RuntimeError("simulated TikTok network failure")
|
||||
if not self._uploaded:
|
||||
return TikTokUploadResult(
|
||||
uploaded=False, publish_id=None, detail="rejected by TikTok"
|
||||
)
|
||||
return TikTokUploadResult(
|
||||
uploaded=True, publish_id=self._publish_id, detail="uploaded"
|
||||
)
|
||||
|
||||
|
||||
async def _seed_video_post(
|
||||
session: AsyncSession,
|
||||
*,
|
||||
platforms: list[str] | None = None,
|
||||
x_caption: str = "Check out this clip",
|
||||
tiktok_caption: str = "Check out this clip on TikTok",
|
||||
) -> TaskTable:
|
||||
for uuid, slug, role in (
|
||||
(SYSTEM_UUID, "system", AgentRole.SYSTEM),
|
||||
(SECRETARY_UUID, "secretary-1", AgentRole.SECRETARY),
|
||||
):
|
||||
if await session.get(AgentTable, uuid) is None:
|
||||
session.add(
|
||||
AgentTable(
|
||||
id=uuid,
|
||||
name=slug,
|
||||
slug=slug,
|
||||
role=role,
|
||||
team=None,
|
||||
status=AgentStatus.ACTIVE,
|
||||
model_config={},
|
||||
system_prompt="x",
|
||||
capabilities=[],
|
||||
permissions={},
|
||||
metrics={},
|
||||
)
|
||||
)
|
||||
await session.flush()
|
||||
project = ProjectTable(
|
||||
id=uuid4(),
|
||||
name="RoboCo",
|
||||
slug=f"roboco-{uuid4().hex[:6]}",
|
||||
git_url="https://example.com/roboco.git",
|
||||
assigned_cell=Team.BACKEND,
|
||||
created_by=SYSTEM_UUID,
|
||||
)
|
||||
session.add(project)
|
||||
await session.flush()
|
||||
task = TaskTable(
|
||||
id=uuid4(),
|
||||
title="Video post: release 1.0",
|
||||
description="script",
|
||||
acceptance_criteria=["CEO approves or rejects the draft"],
|
||||
status=TS.PENDING,
|
||||
priority=2,
|
||||
task_type=TT.ADMINISTRATIVE,
|
||||
nature=TN.NON_TECHNICAL,
|
||||
estimated_complexity=Complexity.LOW,
|
||||
project_id=project.id,
|
||||
created_by=SYSTEM_UUID,
|
||||
assigned_to=SECRETARY_UUID,
|
||||
team=Team.MAIN_PM,
|
||||
source=VIDEO_POST_SOURCE,
|
||||
confirmed_by_human=False,
|
||||
)
|
||||
session.add(task)
|
||||
await session.flush()
|
||||
markers.set_video_draft(
|
||||
task,
|
||||
{
|
||||
"occasion": "release 1.0",
|
||||
"script": "script",
|
||||
"platforms": platforms if platforms is not None else ["x", "tiktok"],
|
||||
"mp4_paths": {"vertical": VERTICAL_MP4, "square": SQUARE_MP4},
|
||||
"x_caption": x_caption,
|
||||
"tiktok_caption": tiktok_caption,
|
||||
"render_status": "rendered",
|
||||
},
|
||||
)
|
||||
await session.flush()
|
||||
return task
|
||||
|
||||
|
||||
def _svc(
|
||||
session: AsyncSession, *, x_poster: XVideoPoster, tiktok_poster: TikTokPoster
|
||||
) -> VideoPostService:
|
||||
return get_video_post_service(
|
||||
session, x_poster=x_poster, tiktok_poster=tiktok_poster
|
||||
)
|
||||
|
||||
|
||||
def _id(task: TaskTable) -> UUID:
|
||||
"""The ORM id typed as stdlib ``uuid.UUID`` for service-call sites."""
|
||||
return cast("UUID", task.id)
|
||||
|
||||
|
||||
_LOCKED = (
|
||||
patch.object(HeartbeatMutex, "acquire", AsyncMock(return_value="tok")),
|
||||
patch.object(HeartbeatMutex, "release", AsyncMock(return_value=None)),
|
||||
)
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_approve_posts_both_platforms_and_completes(
|
||||
db_session: AsyncSession,
|
||||
) -> None:
|
||||
task = await _seed_video_post(db_session)
|
||||
x_poster = _StubXPoster()
|
||||
tiktok_poster = _StubTikTokPoster()
|
||||
with _LOCKED[0], _LOCKED[1]:
|
||||
result = await _svc(
|
||||
db_session, x_poster=x_poster, tiktok_poster=tiktok_poster
|
||||
).approve(_id(task))
|
||||
assert result is not None
|
||||
assert result.status == "posted"
|
||||
assert result.posted == {"x": "x-vid-1", "tiktok": "tt-pub-1"}
|
||||
# X gets the square cut, TikTok the vertical cut.
|
||||
assert x_poster.calls == [(SQUARE_MP4, "Check out this clip")]
|
||||
assert tiktok_poster.calls == [(VERTICAL_MP4, "Check out this clip on TikTok")]
|
||||
await db_session.refresh(task)
|
||||
assert task.status == TS.COMPLETED
|
||||
draft = markers.get_video_draft(task)
|
||||
assert draft is not None
|
||||
assert draft["x_posted_id"] == "x-vid-1"
|
||||
assert draft["tiktok_posted_id"] == "tt-pub-1"
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_approve_single_platform_only_calls_that_poster(
|
||||
db_session: AsyncSession,
|
||||
) -> None:
|
||||
task = await _seed_video_post(db_session, platforms=["x"])
|
||||
x_poster = _StubXPoster()
|
||||
tiktok_poster = _StubTikTokPoster()
|
||||
with _LOCKED[0], _LOCKED[1]:
|
||||
result = await _svc(
|
||||
db_session, x_poster=x_poster, tiktok_poster=tiktok_poster
|
||||
).approve(_id(task))
|
||||
assert result is not None
|
||||
assert result.status == "posted"
|
||||
assert result.posted == {"x": "x-vid-1"}
|
||||
assert x_poster.calls == [(SQUARE_MP4, "Check out this clip")]
|
||||
assert tiktok_poster.calls == [] # never invoked — not in this draft's platforms
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_approve_is_idempotent_second_call_is_noop(
|
||||
db_session: AsyncSession,
|
||||
) -> None:
|
||||
task = await _seed_video_post(db_session)
|
||||
x_poster = _StubXPoster()
|
||||
tiktok_poster = _StubTikTokPoster()
|
||||
svc = _svc(db_session, x_poster=x_poster, tiktok_poster=tiktok_poster)
|
||||
with _LOCKED[0], _LOCKED[1]:
|
||||
first = await svc.approve(_id(task))
|
||||
second = await svc.approve(_id(task))
|
||||
assert first is not None
|
||||
assert first.status == "posted"
|
||||
assert second is not None
|
||||
assert second.status == "already_posted"
|
||||
assert second.posted == {"x": "x-vid-1", "tiktok": "tt-pub-1"}
|
||||
# Neither poster was called a second time.
|
||||
assert len(x_poster.calls) == 1
|
||||
assert len(tiktok_poster.calls) == 1
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_approve_concurrent_lock_held_returns_in_progress(
|
||||
db_session: AsyncSession,
|
||||
) -> None:
|
||||
task = await _seed_video_post(db_session)
|
||||
x_poster = _StubXPoster()
|
||||
tiktok_poster = _StubTikTokPoster()
|
||||
with patch.object(HeartbeatMutex, "acquire", AsyncMock(return_value=None)):
|
||||
result = await _svc(
|
||||
db_session, x_poster=x_poster, tiktok_poster=tiktok_poster
|
||||
).approve(_id(task))
|
||||
assert result is not None
|
||||
assert result.status == "already_in_progress"
|
||||
assert x_poster.calls == []
|
||||
assert tiktok_poster.calls == []
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_approve_redis_unavailable_fails_closed(db_session: AsyncSession) -> None:
|
||||
task = await _seed_video_post(db_session)
|
||||
x_poster = _StubXPoster()
|
||||
tiktok_poster = _StubTikTokPoster()
|
||||
broken = MagicMock()
|
||||
broken.set = AsyncMock(side_effect=ConnectionError("redis down"))
|
||||
broken.aclose = AsyncMock()
|
||||
with patch("roboco.services.heartbeat_mutex.redis.from_url", return_value=broken):
|
||||
result = await _svc(
|
||||
db_session, x_poster=x_poster, tiktok_poster=tiktok_poster
|
||||
).approve(_id(task))
|
||||
assert result is not None
|
||||
assert result.status == "redis_unavailable"
|
||||
assert x_poster.calls == []
|
||||
assert tiktok_poster.calls == []
|
||||
await db_session.refresh(task)
|
||||
assert task.status == TS.PENDING # never advanced without the mutex
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_approve_applies_edited_captions_before_posting(
|
||||
db_session: AsyncSession,
|
||||
) -> None:
|
||||
task = await _seed_video_post(db_session)
|
||||
x_poster = _StubXPoster()
|
||||
tiktok_poster = _StubTikTokPoster()
|
||||
with _LOCKED[0], _LOCKED[1]:
|
||||
result = await _svc(
|
||||
db_session, x_poster=x_poster, tiktok_poster=tiktok_poster
|
||||
).approve(
|
||||
_id(task),
|
||||
x_caption="Edited X caption",
|
||||
tiktok_caption="Edited TikTok caption",
|
||||
)
|
||||
assert result is not None
|
||||
assert result.status == "posted"
|
||||
assert x_poster.calls == [(SQUARE_MP4, "Edited X caption")]
|
||||
assert tiktok_poster.calls == [(VERTICAL_MP4, "Edited TikTok caption")]
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_approve_rejects_edited_x_caption_over_280_chars(
|
||||
db_session: AsyncSession,
|
||||
) -> None:
|
||||
task = await _seed_video_post(db_session)
|
||||
svc = _svc(db_session, x_poster=_StubXPoster(), tiktok_poster=_StubTikTokPoster())
|
||||
with pytest.raises(VideoCaptionTooLongError):
|
||||
await svc.approve(_id(task), x_caption="x" * 281)
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_approve_rejects_edited_tiktok_caption_over_2200_chars(
|
||||
db_session: AsyncSession,
|
||||
) -> None:
|
||||
task = await _seed_video_post(db_session)
|
||||
svc = _svc(db_session, x_poster=_StubXPoster(), tiktok_poster=_StubTikTokPoster())
|
||||
with pytest.raises(VideoCaptionTooLongError):
|
||||
await svc.approve(_id(task), tiktok_caption="x" * 2201)
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_approve_partial_failure_keeps_task_open_and_persists_the_success(
|
||||
db_session: AsyncSession, _test_database_url: str
|
||||
) -> None:
|
||||
"""Unlike every other approve() test in this file, this one commits a
|
||||
non-terminal (PENDING) video_post row via db_session and never drives it
|
||||
to a terminal state — every other test either never commits (rolled
|
||||
back at teardown) or ends COMPLETED (excluded from the open-task
|
||||
queries). Left behind, it leaks into the shared session-scoped test DB
|
||||
and breaks list_open_video_posts()/list_open_video_post_drafts()
|
||||
assertions in test_video_engine.py / test_video_render_loop.py, which
|
||||
run later in the same pytest session. Clean it up via its own
|
||||
committed session regardless of pass/fail."""
|
||||
task = await _seed_video_post(db_session)
|
||||
task_id = _id(task)
|
||||
project_id = task.project_id
|
||||
try:
|
||||
x_poster = _StubXPoster(posted=False)
|
||||
tiktok_poster = _StubTikTokPoster()
|
||||
with _LOCKED[0], _LOCKED[1]:
|
||||
result = await _svc(
|
||||
db_session, x_poster=x_poster, tiktok_poster=tiktok_poster
|
||||
).approve(task_id)
|
||||
assert result is not None
|
||||
assert result.status == "posted_partial"
|
||||
assert result.posted == {"tiktok": "tt-pub-1"}
|
||||
await db_session.refresh(task)
|
||||
assert task.status == TS.PENDING # not completed — X still needs a retry
|
||||
draft = markers.get_video_draft(task)
|
||||
assert draft is not None
|
||||
assert draft["tiktok_posted_id"] == "tt-pub-1"
|
||||
assert "x_posted_id" not in draft
|
||||
finally:
|
||||
cleanup, cleanup_engine = await _fresh_session(_test_database_url)
|
||||
try:
|
||||
await cleanup.execute(delete(TaskTable).where(TaskTable.id == task_id))
|
||||
await cleanup.execute(
|
||||
delete(ProjectTable).where(ProjectTable.id == project_id)
|
||||
)
|
||||
await cleanup.commit()
|
||||
finally:
|
||||
await _dispose(cleanup, cleanup_engine)
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_approve_retry_skips_the_already_posted_platform(
|
||||
db_session: AsyncSession,
|
||||
) -> None:
|
||||
"""A retry after a partial failure must not re-post the platform that
|
||||
already succeeded — only the still-pending one is attempted again."""
|
||||
task = await _seed_video_post(db_session)
|
||||
x_poster = _StubXPoster(posted=False)
|
||||
tiktok_poster = _StubTikTokPoster()
|
||||
svc = _svc(db_session, x_poster=x_poster, tiktok_poster=tiktok_poster)
|
||||
with _LOCKED[0], _LOCKED[1]:
|
||||
first = await svc.approve(_id(task))
|
||||
assert first is not None
|
||||
assert first.status == "posted_partial"
|
||||
x_poster._posted = True # credentials fixed between attempts
|
||||
second = await svc.approve(_id(task))
|
||||
assert second is not None
|
||||
assert second.status == "posted"
|
||||
assert second.posted == {"x": "x-vid-1", "tiktok": "tt-pub-1"}
|
||||
# TikTok succeeded on attempt 1 and must not be re-uploaded on the retry;
|
||||
# X failed on attempt 1 so IS legitimately retried (and succeeds this time).
|
||||
assert len(tiktok_poster.calls) == 1
|
||||
assert len(x_poster.calls) == TWO
|
||||
|
||||
|
||||
async def _fresh_session(url: str) -> tuple[AsyncSession, AsyncEngine]:
|
||||
"""A session on a brand-new engine/connection (caller disposes)."""
|
||||
engine = create_async_engine(url, future=True)
|
||||
factory = async_sessionmaker(
|
||||
bind=engine, class_=AsyncSession, expire_on_commit=False
|
||||
)
|
||||
return factory(), engine
|
||||
|
||||
|
||||
async def _dispose(session: AsyncSession, engine: AsyncEngine) -> None:
|
||||
with contextlib.suppress(Exception):
|
||||
await session.rollback()
|
||||
await engine.dispose()
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_approve_partial_failure_persists_success_durably_across_sessions(
|
||||
db_session: AsyncSession, _test_database_url: str
|
||||
) -> None:
|
||||
"""`db_session` read-your-own-writes can hide a durability gap: platform
|
||||
1 (x) posts, platform 2 (tiktok)'s poster RAISES. X's posted-id must be
|
||||
committed for real — visible from a completely INDEPENDENT session and
|
||||
connection, not merely flushed on the session that ran approve() — and a
|
||||
retry from yet another fresh session must not re-invoke x's poster."""
|
||||
task = await _seed_video_post(db_session)
|
||||
task_id = _id(task)
|
||||
x_poster = _StubXPoster()
|
||||
tiktok_poster = _StubTikTokPoster(raises=True)
|
||||
with _LOCKED[0], _LOCKED[1]:
|
||||
result = await _svc(
|
||||
db_session, x_poster=x_poster, tiktok_poster=tiktok_poster
|
||||
).approve(task_id)
|
||||
assert result is not None
|
||||
assert result.status == "posted_partial"
|
||||
assert result.posted == {"x": "x-vid-1"}
|
||||
|
||||
# A brand-new session/connection — never touched db_session — must see
|
||||
# x's posted id as durably committed, not just flushed-in-memory there.
|
||||
fresh, fresh_engine = await _fresh_session(_test_database_url)
|
||||
try:
|
||||
fresh_task = await fresh.get(TaskTable, task_id)
|
||||
assert fresh_task is not None
|
||||
assert fresh_task.status == TS.PENDING
|
||||
fresh_draft = markers.get_video_draft(fresh_task)
|
||||
assert fresh_draft is not None
|
||||
assert fresh_draft["x_posted_id"] == "x-vid-1"
|
||||
assert "tiktok_posted_id" not in fresh_draft
|
||||
finally:
|
||||
await _dispose(fresh, fresh_engine)
|
||||
|
||||
# Retry from yet ANOTHER fresh session (a brand-new request): x must not
|
||||
# be re-invoked — only the still-pending tiktok platform is retried.
|
||||
tiktok_poster._raises = False
|
||||
retry_session, retry_engine = await _fresh_session(_test_database_url)
|
||||
try:
|
||||
with _LOCKED[0], _LOCKED[1]:
|
||||
retry = await _svc(
|
||||
retry_session, x_poster=x_poster, tiktok_poster=tiktok_poster
|
||||
).approve(task_id)
|
||||
finally:
|
||||
await _dispose(retry_session, retry_engine)
|
||||
assert retry is not None
|
||||
assert retry.status == "posted"
|
||||
assert retry.posted == {"x": "x-vid-1", "tiktok": "tt-pub-1"}
|
||||
assert len(x_poster.calls) == 1 # never re-invoked on the retry
|
||||
assert len(tiktok_poster.calls) == TWO # the raise, then the successful retry
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_approve_unknown_task_returns_none(db_session: AsyncSession) -> None:
|
||||
result = await _svc(
|
||||
db_session, x_poster=_StubXPoster(), tiktok_poster=_StubTikTokPoster()
|
||||
).approve(uuid4())
|
||||
assert result is None
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_reject_records_reason_and_cancels(db_session: AsyncSession) -> None:
|
||||
task = await _seed_video_post(db_session)
|
||||
updated = await _svc(
|
||||
db_session, x_poster=_StubXPoster(), tiktok_poster=_StubTikTokPoster()
|
||||
).reject(_id(task), "Doesn't match the release")
|
||||
assert updated is not None
|
||||
assert updated.status == TS.CANCELLED
|
||||
assert markers.get_video_reject_reason(updated) == "Doesn't match the release"
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_list_held_video_posts_excludes_terminal(
|
||||
db_session: AsyncSession,
|
||||
) -> None:
|
||||
open_task = await _seed_video_post(db_session)
|
||||
rejected_task = await _seed_video_post(db_session)
|
||||
svc = _svc(db_session, x_poster=_StubXPoster(), tiktok_poster=_StubTikTokPoster())
|
||||
await svc.reject(_id(rejected_task), "not relevant")
|
||||
held = await svc.list_held_video_posts()
|
||||
ids = {t.id for t in held}
|
||||
assert open_task.id in ids
|
||||
assert rejected_task.id not in ids
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_approve_commits_before_releasing_the_lock(
|
||||
db_session: AsyncSession, monkeypatch: pytest.MonkeyPatch
|
||||
) -> None:
|
||||
"""The double-post guard depends on this ordering: every commit (each
|
||||
platform success, then COMPLETED) must be durable before the lock is
|
||||
released, or a racing approve could acquire the lock the instant it's
|
||||
dropped and post again before a commit lands. Both platforms succeed
|
||||
here, so this lands 3 commits (one per platform + COMPLETED) — asserts
|
||||
the ordering property, not a hard-coded count of an implementation
|
||||
detail."""
|
||||
task = await _seed_video_post(db_session)
|
||||
order: list[str] = []
|
||||
|
||||
real_commit = db_session.commit
|
||||
|
||||
async def _spy_commit() -> None:
|
||||
await real_commit()
|
||||
order.append("commit")
|
||||
|
||||
monkeypatch.setattr(db_session, "commit", _spy_commit)
|
||||
|
||||
async def _spy_release(_self: HeartbeatMutex, _token: str) -> None:
|
||||
order.append("release")
|
||||
|
||||
with (
|
||||
patch.object(HeartbeatMutex, "acquire", AsyncMock(return_value="tok")),
|
||||
patch.object(HeartbeatMutex, "release", _spy_release),
|
||||
):
|
||||
result = await _svc(
|
||||
db_session, x_poster=_StubXPoster(), tiktok_poster=_StubTikTokPoster()
|
||||
).approve(_id(task))
|
||||
assert result is not None
|
||||
assert result.status == "posted"
|
||||
assert order[-1] == "release"
|
||||
assert order.count("release") == 1
|
||||
assert order[:-1] == ["commit"] * (len(order) - 1)
|
||||
assert len(order) > 1 # at least one commit landed before the release
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_approve_rechecks_completed_under_lock_and_never_reposts(
|
||||
db_session: AsyncSession,
|
||||
) -> None:
|
||||
"""A concurrent approve wins the lock, posts, and commits COMPLETED after
|
||||
our pre-lock read. Once we acquire the lock, the in-lock re-read must see
|
||||
COMPLETED and short-circuit — never re-posting."""
|
||||
task = await _seed_video_post(db_session)
|
||||
x_poster = _StubXPoster()
|
||||
tiktok_poster = _StubTikTokPoster()
|
||||
|
||||
async def _win_the_race(_self: HeartbeatMutex) -> str:
|
||||
draft = dict(markers.get_video_draft(task) or {})
|
||||
draft["x_posted_id"] = "x-winner"
|
||||
draft["tiktok_posted_id"] = "tt-winner"
|
||||
markers.set_video_draft(task, draft)
|
||||
task.status = TS.COMPLETED
|
||||
await db_session.flush()
|
||||
return "tok"
|
||||
|
||||
with (
|
||||
patch.object(HeartbeatMutex, "acquire", _win_the_race),
|
||||
patch.object(HeartbeatMutex, "release", AsyncMock(return_value=None)),
|
||||
):
|
||||
result = await _svc(
|
||||
db_session, x_poster=x_poster, tiktok_poster=tiktok_poster
|
||||
).approve(_id(task))
|
||||
assert result is not None
|
||||
assert result.status == "already_posted"
|
||||
assert result.posted == {"x": "x-winner", "tiktok": "tt-winner"}
|
||||
assert x_poster.calls == []
|
||||
assert tiktok_poster.calls == []
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_approve_concurrent_caption_edit_does_not_erase_a_committed_posted_id(
|
||||
db_session: AsyncSession, _test_database_url: str
|
||||
) -> None:
|
||||
"""RC1 regression: a caption edit must never write the draft column
|
||||
before the lock. The old pre-lock flush computed its update from a read
|
||||
taken before a genuinely concurrent approve (a different session/
|
||||
connection) posted + committed a platform's id; once THIS session later
|
||||
commits under the lock, that stale write won and erased the concurrent
|
||||
commit — the retry re-posted the platform (a double-post)."""
|
||||
task = await _seed_video_post(db_session, platforms=["x", "tiktok"])
|
||||
task_id = _id(task)
|
||||
await db_session.commit() # externally visible to the "concurrent" session below
|
||||
|
||||
real_get = TaskService.get
|
||||
injected = False
|
||||
|
||||
async def _get_then_inject_concurrent_post(
|
||||
self: TaskService, tid: UUID
|
||||
) -> TaskTable | None:
|
||||
"""Fires once, right after the outer pre-lock read — the exact
|
||||
window between our read and our own (would-be) pre-lock write."""
|
||||
nonlocal injected
|
||||
result = await real_get(self, tid)
|
||||
if not injected:
|
||||
injected = True
|
||||
other, other_engine = await _fresh_session(_test_database_url)
|
||||
try:
|
||||
other_task = await other.get(TaskTable, tid)
|
||||
assert other_task is not None
|
||||
other_draft = dict(markers.get_video_draft(other_task) or {})
|
||||
other_draft["x_posted_id"] = "x-concurrent"
|
||||
markers.set_video_draft(other_task, other_draft)
|
||||
await other.commit()
|
||||
finally:
|
||||
await _dispose(other, other_engine)
|
||||
return result
|
||||
|
||||
x_poster = _StubXPoster()
|
||||
tiktok_poster = _StubTikTokPoster()
|
||||
with (
|
||||
patch.object(TaskService, "get", _get_then_inject_concurrent_post),
|
||||
_LOCKED[0],
|
||||
_LOCKED[1],
|
||||
):
|
||||
result = await _svc(
|
||||
db_session, x_poster=x_poster, tiktok_poster=tiktok_poster
|
||||
).approve(task_id, x_caption="Edited X caption")
|
||||
|
||||
assert result is not None
|
||||
# X must never be re-posted — the concurrently committed id survives.
|
||||
assert x_poster.calls == []
|
||||
assert result.posted.get("x") == "x-concurrent"
|
||||
assert tiktok_poster.calls == [(VERTICAL_MP4, "Check out this clip on TikTok")]
|
||||
|
||||
fresh, fresh_engine = await _fresh_session(_test_database_url)
|
||||
try:
|
||||
final = await fresh.get(TaskTable, task_id)
|
||||
assert final is not None
|
||||
final_draft = markers.get_video_draft(final)
|
||||
assert final_draft is not None
|
||||
assert final_draft["x_posted_id"] == "x-concurrent" # not erased
|
||||
assert final_draft["x_caption"] == "Edited X caption" # edit still applied
|
||||
finally:
|
||||
await _dispose(fresh, fresh_engine)
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_approve_cancel_during_a_platform_commit_leaves_it_durable_and_usable(
|
||||
db_session: AsyncSession,
|
||||
monkeypatch: pytest.MonkeyPatch,
|
||||
_test_database_url: str,
|
||||
) -> None:
|
||||
"""RC2 regression: a lock-loss cancellation firing while a per-platform
|
||||
commit is in flight used to interrupt asyncio's own await on that
|
||||
commit — rolling it back (so a retry re-posts the same platform) and
|
||||
leaving the session unusable for anything that runs after (a route's
|
||||
get_db teardown 500s on the poisoned session). Fixed: the commit is
|
||||
asyncio.shield()ed so it always finishes, and the lock_lost path rolls
|
||||
back explicitly so the session is guaranteed clean for reuse.
|
||||
|
||||
A lock_lost result never reaches _finalize_post, so the task is left
|
||||
PENDING (non-terminal) even though its one platform posted — unlike
|
||||
every other approve() test in this file, this one must clean up its own
|
||||
committed row (see the note on test_approve_partial_failure_keeps_task_
|
||||
open_and_persists_the_success for why that matters)."""
|
||||
task = await _seed_video_post(db_session, platforms=["x"])
|
||||
task_id = _id(task)
|
||||
project_id = task.project_id
|
||||
await db_session.commit() # a prior committed transaction, isolating the
|
||||
# racy platform-commit below to its OWN transaction — so a rollback of
|
||||
# that transaction can't also undo the seed itself.
|
||||
|
||||
try:
|
||||
x_poster = _StubXPoster()
|
||||
tiktok_poster = _StubTikTokPoster()
|
||||
|
||||
real_commit = db_session.commit
|
||||
commit_started = asyncio.Event()
|
||||
|
||||
async def _slow_commit() -> None:
|
||||
commit_started.set()
|
||||
await real_commit()
|
||||
|
||||
monkeypatch.setattr(db_session, "commit", _slow_commit)
|
||||
|
||||
async def _lose_the_lock_once_committing(
|
||||
_self: HeartbeatMutex, _token: str
|
||||
) -> bool:
|
||||
await commit_started.wait()
|
||||
return False # lock lost -- cancels the guarded task fail-closed
|
||||
|
||||
with (
|
||||
patch.object(HeartbeatMutex, "acquire", AsyncMock(return_value="tok")),
|
||||
patch.object(HeartbeatMutex, "release", AsyncMock(return_value=None)),
|
||||
patch.object(
|
||||
HeartbeatMutex, "heartbeat_once", _lose_the_lock_once_committing
|
||||
),
|
||||
):
|
||||
result = await _svc(
|
||||
db_session, x_poster=x_poster, tiktok_poster=tiktok_poster
|
||||
).approve(task_id)
|
||||
|
||||
assert result is not None
|
||||
assert result.status == "lock_lost"
|
||||
assert x_poster.calls == [(SQUARE_MP4, "Check out this clip")] # it DID post
|
||||
|
||||
# Durable: a brand-new connection sees the id even though the
|
||||
# guarded task was cancelled mid-commit.
|
||||
fresh, fresh_engine = await _fresh_session(_test_database_url)
|
||||
try:
|
||||
final = await fresh.get(TaskTable, task_id)
|
||||
assert final is not None
|
||||
final_draft = markers.get_video_draft(final)
|
||||
assert final_draft is not None
|
||||
assert final_draft["x_posted_id"] == "x-vid-1"
|
||||
finally:
|
||||
await _dispose(fresh, fresh_engine)
|
||||
|
||||
# The session itself must still be usable afterward — not poisoned
|
||||
# by the cancelled-mid-commit path.
|
||||
monkeypatch.setattr(db_session, "commit", real_commit)
|
||||
check = await db_session.get(TaskTable, task_id)
|
||||
assert check is not None
|
||||
await db_session.commit() # would raise if the session were poisoned
|
||||
finally:
|
||||
cleanup, cleanup_engine = await _fresh_session(_test_database_url)
|
||||
try:
|
||||
await cleanup.execute(delete(TaskTable).where(TaskTable.id == task_id))
|
||||
await cleanup.execute(
|
||||
delete(ProjectTable).where(ProjectTable.id == project_id)
|
||||
)
|
||||
await cleanup.commit()
|
||||
finally:
|
||||
await _dispose(cleanup, cleanup_engine)
|
||||
@@ -0,0 +1,244 @@
|
||||
"""LiveXVideoPoster coverage: the v2 media-upload sequence (initialize ->
|
||||
append -> finalize -> STATUS poll -> tweet) against a fake httpx transport,
|
||||
plus the Null/Live build branching."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from typing import TYPE_CHECKING
|
||||
|
||||
import httpx
|
||||
import pytest
|
||||
from roboco.services.video_post_service import NullXVideoPoster
|
||||
from roboco.services.x_credentials import XCredentialsData
|
||||
from roboco.services.x_video_client import (
|
||||
LiveXVideoPoster,
|
||||
build_x_video_poster,
|
||||
)
|
||||
|
||||
if TYPE_CHECKING:
|
||||
from pathlib import Path
|
||||
|
||||
_CREDS = XCredentialsData(
|
||||
api_key="ak-test",
|
||||
api_secret="as-test",
|
||||
access_token="at-test",
|
||||
access_token_secret="ats-test",
|
||||
)
|
||||
THREE = 3
|
||||
|
||||
|
||||
def test_build_without_creds_returns_null() -> None:
|
||||
poster = build_x_video_poster(None, timeout=5.0)
|
||||
assert isinstance(poster, NullXVideoPoster)
|
||||
assert poster.configured is False
|
||||
|
||||
|
||||
def test_build_with_creds_returns_live() -> None:
|
||||
poster = build_x_video_poster(_CREDS, timeout=5.0)
|
||||
assert isinstance(poster, LiveXVideoPoster)
|
||||
assert poster.configured is True
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_null_poster_post_video_is_a_noop() -> None:
|
||||
result = await NullXVideoPoster().post_video(mp4_path="/tmp/x.mp4", caption="hi")
|
||||
assert result.posted is False
|
||||
assert result.video_id is None
|
||||
|
||||
|
||||
def _write_clip(tmp_path: Path, data: bytes = b"fake-mp4-bytes") -> str:
|
||||
mp4 = tmp_path / "clip.mp4"
|
||||
mp4.write_bytes(data)
|
||||
return str(mp4)
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_post_video_full_sequence_with_processing_poll(
|
||||
tmp_path: Path, monkeypatch: pytest.MonkeyPatch
|
||||
) -> None:
|
||||
"""The whole verified §11.2 sequence: initialize -> append -> finalize
|
||||
(pending) -> GET STATUS (succeeded) -> POST /2/tweets."""
|
||||
calls: list[tuple[str, str]] = []
|
||||
|
||||
async def _no_sleep(_seconds: float) -> None:
|
||||
return None
|
||||
|
||||
monkeypatch.setattr("roboco.services.x_video_client.asyncio.sleep", _no_sleep)
|
||||
|
||||
def handler(request: httpx.Request) -> httpx.Response:
|
||||
calls.append((request.method, request.url.path))
|
||||
assert request.headers["Authorization"].startswith("OAuth ")
|
||||
path = request.url.path
|
||||
if path == "/2/media/upload/initialize":
|
||||
return httpx.Response(
|
||||
202, json={"data": {"id": "media123", "media_key": "3_123"}}
|
||||
)
|
||||
if path == "/2/media/upload/media123/append":
|
||||
return httpx.Response(204)
|
||||
if path == "/2/media/upload/media123/finalize":
|
||||
return httpx.Response(
|
||||
201,
|
||||
json={
|
||||
"data": {
|
||||
"id": "media123",
|
||||
"processing_info": {"state": "pending", "check_after_secs": 1},
|
||||
}
|
||||
},
|
||||
)
|
||||
if path == "/2/media/upload" and request.url.params.get("command") == "STATUS":
|
||||
assert request.url.params.get("media_id") == "media123"
|
||||
return httpx.Response(
|
||||
200, json={"data": {"processing_info": {"state": "succeeded"}}}
|
||||
)
|
||||
if path == "/2/tweets":
|
||||
return httpx.Response(201, json={"data": {"id": "tweet789"}})
|
||||
raise AssertionError(f"unexpected request {request.method} {path}")
|
||||
|
||||
transport = httpx.MockTransport(handler)
|
||||
http_client = httpx.AsyncClient(transport=transport)
|
||||
poster = LiveXVideoPoster(_CREDS, timeout=5.0, client=http_client)
|
||||
result = await poster.post_video(
|
||||
mp4_path=_write_clip(tmp_path), caption="Check this out"
|
||||
)
|
||||
await http_client.aclose()
|
||||
|
||||
assert result.posted is True
|
||||
assert result.video_id == "tweet789"
|
||||
paths = [p for _, p in calls]
|
||||
assert paths.count("/2/media/upload/initialize") == 1
|
||||
assert paths.count("/2/media/upload/media123/append") == 1
|
||||
assert paths.count("/2/media/upload/media123/finalize") == 1
|
||||
assert paths.count("/2/media/upload") == 1 # the STATUS poll
|
||||
assert paths.count("/2/tweets") == 1
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_post_video_skips_poll_when_finalize_has_no_processing_info(
|
||||
tmp_path: Path,
|
||||
) -> None:
|
||||
"""A finalize response with no processing_info means already usable —
|
||||
no STATUS poll is issued at all."""
|
||||
calls: list[str] = []
|
||||
|
||||
def handler(request: httpx.Request) -> httpx.Response:
|
||||
calls.append(request.url.path)
|
||||
path = request.url.path
|
||||
if path == "/2/media/upload/initialize":
|
||||
return httpx.Response(202, json={"data": {"id": "media1"}})
|
||||
if path == "/2/media/upload/media1/append":
|
||||
return httpx.Response(204)
|
||||
if path == "/2/media/upload/media1/finalize":
|
||||
return httpx.Response(201, json={"data": {"id": "media1"}})
|
||||
if path == "/2/tweets":
|
||||
return httpx.Response(201, json={"data": {"id": "tweet1"}})
|
||||
raise AssertionError(f"unexpected request {path}")
|
||||
|
||||
transport = httpx.MockTransport(handler)
|
||||
http_client = httpx.AsyncClient(transport=transport)
|
||||
poster = LiveXVideoPoster(_CREDS, timeout=5.0, client=http_client)
|
||||
result = await poster.post_video(mp4_path=_write_clip(tmp_path), caption="hi")
|
||||
await http_client.aclose()
|
||||
|
||||
assert result.posted is True
|
||||
assert "/2/media/upload" not in calls # STATUS GET never fired
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_post_video_appends_in_multiple_chunks(
|
||||
tmp_path: Path, monkeypatch: pytest.MonkeyPatch
|
||||
) -> None:
|
||||
"""A file bigger than the chunk size is appended across several calls
|
||||
(shrink the module chunk size rather than allocating real megabytes)."""
|
||||
monkeypatch.setattr("roboco.services.x_video_client._CHUNK_SIZE_BYTES", 4)
|
||||
append_calls: list[str] = []
|
||||
|
||||
def handler(request: httpx.Request) -> httpx.Response:
|
||||
path = request.url.path
|
||||
if path == "/2/media/upload/initialize":
|
||||
return httpx.Response(202, json={"data": {"id": "media1"}})
|
||||
if path == "/2/media/upload/media1/append":
|
||||
append_calls.append(str(request.content))
|
||||
return httpx.Response(204)
|
||||
if path == "/2/media/upload/media1/finalize":
|
||||
return httpx.Response(201, json={"data": {"id": "media1"}})
|
||||
if path == "/2/tweets":
|
||||
return httpx.Response(201, json={"data": {"id": "tweet1"}})
|
||||
raise AssertionError(f"unexpected request {path}")
|
||||
|
||||
transport = httpx.MockTransport(handler)
|
||||
http_client = httpx.AsyncClient(transport=transport)
|
||||
poster = LiveXVideoPoster(_CREDS, timeout=5.0, client=http_client)
|
||||
result = await poster.post_video(
|
||||
mp4_path=_write_clip(tmp_path, b"0123456789"), caption="hi"
|
||||
)
|
||||
await http_client.aclose()
|
||||
|
||||
assert result.posted is True
|
||||
assert len(append_calls) == THREE # ceil(10 / 4) == 3 chunks
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_post_video_initialize_failure_is_graceful(tmp_path: Path) -> None:
|
||||
def handler(_request: httpx.Request) -> httpx.Response:
|
||||
return httpx.Response(401, text="unauthorized")
|
||||
|
||||
transport = httpx.MockTransport(handler)
|
||||
http_client = httpx.AsyncClient(transport=transport)
|
||||
poster = LiveXVideoPoster(_CREDS, timeout=5.0, client=http_client)
|
||||
result = await poster.post_video(mp4_path=_write_clip(tmp_path), caption="hi")
|
||||
await http_client.aclose()
|
||||
|
||||
assert result.posted is False
|
||||
assert result.video_id is None
|
||||
assert "401" in result.detail
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_post_video_processing_failed_state_is_graceful(
|
||||
tmp_path: Path, monkeypatch: pytest.MonkeyPatch
|
||||
) -> None:
|
||||
async def _no_sleep(_seconds: float) -> None:
|
||||
return None
|
||||
|
||||
monkeypatch.setattr("roboco.services.x_video_client.asyncio.sleep", _no_sleep)
|
||||
|
||||
def handler(request: httpx.Request) -> httpx.Response:
|
||||
path = request.url.path
|
||||
if path == "/2/media/upload/initialize":
|
||||
return httpx.Response(202, json={"data": {"id": "media1"}})
|
||||
if path == "/2/media/upload/media1/append":
|
||||
return httpx.Response(204)
|
||||
if path == "/2/media/upload/media1/finalize":
|
||||
return httpx.Response(
|
||||
201,
|
||||
json={
|
||||
"data": {
|
||||
"processing_info": {
|
||||
"state": "pending",
|
||||
"check_after_secs": 0,
|
||||
}
|
||||
}
|
||||
},
|
||||
)
|
||||
if path == "/2/media/upload" and request.url.params.get("command") == "STATUS":
|
||||
return httpx.Response(
|
||||
200,
|
||||
json={
|
||||
"data": {
|
||||
"processing_info": {
|
||||
"state": "failed",
|
||||
"error": {"message": "invalid video format"},
|
||||
}
|
||||
}
|
||||
},
|
||||
)
|
||||
raise AssertionError(f"unexpected request {path}")
|
||||
|
||||
transport = httpx.MockTransport(handler)
|
||||
http_client = httpx.AsyncClient(transport=transport)
|
||||
poster = LiveXVideoPoster(_CREDS, timeout=5.0, client=http_client)
|
||||
result = await poster.post_video(mp4_path=_write_clip(tmp_path), caption="hi")
|
||||
await http_client.aclose()
|
||||
|
||||
assert result.posted is False
|
||||
assert "processing failed" in result.detail
|
||||
Reference in New Issue
Block a user