Skip to content

Self-hosted AI workspace.

Python

test(media): stop asserting an optional ffmpeg webp encoder

Léoeb98aa6dc2fb
diff --git a/tests/test_inspect_media_tool.py b/tests/test_inspect_media_tool.py
index f6ebc64ae..4190a2dc4 100644
--- a/tests/test_inspect_media_tool.py
+++ b/tests/test_inspect_media_tool.py
@@ -1,5 +1,6 @@
import asyncio
import base64
+import functools
import io
import json
from pathlib import Path
@@ -20,6 +21,28 @@ from src.tool_execution import _active_workspace
from src.tool_schemas import FUNCTION_TOOL_SCHEMAS
[email protected]_cache(maxsize=None)
+def _ffmpeg_has_encoder(name: str) -> bool:
+ """Whether the ffmpeg on PATH was built with the named encoder.
+
+ Codec support is a build option, not something the project requires. The
+ Homebrew ffmpeg on macOS ships without libwebp, for instance, so a test
+ that asserts a successful `.webp` export there fails on the build rather
+ than on the tool.
+ """
+ if not shutil.which("ffmpeg"):
+ return False
+ listed = subprocess.run(
+ ["ffmpeg", "-hide_banner", "-loglevel", "error", "-encoders"],
+ check=False, capture_output=True, text=True,
+ )
+ return any(
+ line.split()[1:2] == [name]
+ for line in listed.stdout.splitlines()
+ if line.strip()
+ )
+
+
def test_media_timestamp_parser_accepts_units_and_four_field_timecodes():
assert _parse_seconds("0m", default=-1) == 0
assert _parse_seconds("30m", default=-1) == 1800
@@ -491,13 +514,16 @@ def test_inspect_media_exports_final_decodable_frame_at_exact_duration(tmp_path:
result = asyncio.run(InspectMediaTool().execute(json.dumps({
"path": "/workspace/video.mp4",
"timestamp": "end",
- "output_path": "/workspace/final.webp",
+ # PNG, not WebP: this asserts that the *final* frame is decodable at
+ # the exact duration, so it must not also depend on an optional
+ # ffmpeg encoder. WebP export is covered separately below.
+ "output_path": "/workspace/final.png",
}), {}))
finally:
_active_workspace.reset(token)
assert result["exit_code"] == 0, result
- assert (tmp_path / "final.webp").stat().st_size > 0
+ assert (tmp_path / "final.png").stat().st_size > 0
token = _active_workspace.set(str(tmp_path))
try:
@@ -514,6 +540,67 @@ def test_inspect_media_exports_final_decodable_frame_at_exact_duration(tmp_path:
assert Image.open(io.BytesIO(base64.b64decode(high_detail["images"][0]["data"]))).size == (768, 432)
[email protected](not shutil.which("ffmpeg") or not shutil.which("ffprobe"), reason="ffmpeg required")
[email protected](not _ffmpeg_has_encoder("webp"), reason="ffmpeg built without a webp encoder")
+def test_inspect_media_exports_a_webp_still(tmp_path: Path):
+ """A `.webp` output_path is passed straight through to ffmpeg.
+
+ Guarded on the encoder rather than asserted unconditionally: WebP is a
+ build option (Homebrew's macOS ffmpeg omits it) and the project does not
+ require it. When the encoder is missing the tool reports ffmpeg's failure
+ with `exit_code` 1, which is covered by
+ `test_inspect_media_reports_a_missing_encoder_instead_of_crashing`.
+ """
+ video = tmp_path / "video.mp4"
+ subprocess.run([
+ "ffmpeg", "-hide_banner", "-loglevel", "error", "-f", "lavfi",
+ "-i", "testsrc2=size=320x180:rate=4:duration=2", "-pix_fmt", "yuv420p",
+ "-y", str(video),
+ ], check=True)
+ token = _active_workspace.set(str(tmp_path))
+ try:
+ result = asyncio.run(InspectMediaTool().execute(json.dumps({
+ "path": "/workspace/video.mp4",
+ "timestamp": "end",
+ "output_path": "/workspace/final.webp",
+ }), {}))
+ finally:
+ _active_workspace.reset(token)
+
+ assert result["exit_code"] == 0, result
+ assert Image.open(tmp_path / "final.webp").format == "WEBP"
+
+
[email protected](not shutil.which("ffmpeg") or not shutil.which("ffprobe"), reason="ffmpeg required")
[email protected](_ffmpeg_has_encoder("webp"), reason="needs an ffmpeg built without webp")
+def test_inspect_media_reports_a_missing_encoder_instead_of_crashing(tmp_path: Path):
+ """An export in a format this ffmpeg cannot encode fails as a tool error.
+
+ The tool does not probe the encoder list, so the only contract it can keep
+ is to surface ffmpeg's own failure rather than raise or write a truncated
+ file. Asserted only on builds that actually lack the encoder.
+ """
+ video = tmp_path / "video.mp4"
+ subprocess.run([
+ "ffmpeg", "-hide_banner", "-loglevel", "error", "-f", "lavfi",
+ "-i", "testsrc2=size=320x180:rate=4:duration=2", "-pix_fmt", "yuv420p",
+ "-y", str(video),
+ ], check=True)
+ token = _active_workspace.set(str(tmp_path))
+ try:
+ result = asyncio.run(InspectMediaTool().execute(json.dumps({
+ "path": "/workspace/video.mp4",
+ "timestamp": "end",
+ "output_path": "/workspace/final.webp",
+ }), {}))
+ finally:
+ _active_workspace.reset(token)
+
+ assert result["exit_code"] == 1
+ assert "ffmpeg still extraction failed" in result["error"]
+ assert not (tmp_path / "final.webp").exists()
+
+
@pytest.mark.skipif(not shutil.which("ffmpeg") or not shutil.which("ffprobe"), reason="ffmpeg required")
def test_inspect_media_rejects_ambiguous_multi_frame_single_image_export(tmp_path: Path):
video = tmp_path / "video.mp4"