Skip to content

Open-source AI podcast clipper. Generate vertical clips with face tracking and burned-in captions. CLI, MCP server, web app.

7.3 KB
Raw Blame
"""Tests for backend.services.media_probe: extracted ffmpeg helpers."""

import os
import sys
import unittest
from unittest import mock

ROOT = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
BACKEND_ROOT = os.path.join(ROOT, "backend")
if BACKEND_ROOT not in sys.path:
    sys.path.insert(0, BACKEND_ROOT)

from services import media_probe


class ParseDurationSecondsTests(unittest.TestCase):
    def test_valid_numeric_string(self):
        self.assertEqual(media_probe.parse_duration_seconds("12.5"), 12.5)

    def test_valid_float(self):
        self.assertEqual(media_probe.parse_duration_seconds(30.0), 30.0)

    def test_rejects_nan(self):
        self.assertIsNone(media_probe.parse_duration_seconds("nan"))
        self.assertIsNone(media_probe.parse_duration_seconds(float("nan")))

    def test_rejects_infinity(self):
        self.assertIsNone(media_probe.parse_duration_seconds(float("inf")))
        self.assertIsNone(media_probe.parse_duration_seconds("inf"))

    def test_rejects_zero_and_negative(self):
        self.assertIsNone(media_probe.parse_duration_seconds(0))
        self.assertIsNone(media_probe.parse_duration_seconds(-5))

    def test_rejects_non_parsable(self):
        self.assertIsNone(media_probe.parse_duration_seconds("N/A"))
        self.assertIsNone(media_probe.parse_duration_seconds(None))
        self.assertIsNone(media_probe.parse_duration_seconds(""))


class GetMediaDurationSecondsTests(unittest.TestCase):
    def test_uses_format_duration_when_valid(self):
        fake_info = {"format": {"duration": "42.5"}, "streams": []}
        with mock.patch.object(media_probe, "get_video_info", return_value=fake_info):
            self.assertEqual(
                media_probe.get_media_duration_seconds("/fake.mp4"), 42.5
            )

    def test_prefers_max_of_format_and_streams(self):
        fake_info = {
            "format": {"duration": "30.0"},
            "streams": [
                {"duration": "29.5"},
                {"duration": "31.0"},  # slightly longer stream
            ],
        }
        with mock.patch.object(media_probe, "get_video_info", return_value=fake_info):
            self.assertEqual(
                media_probe.get_media_duration_seconds("/fake.mp4"), 31.0
            )

    def test_falls_back_to_default_when_all_invalid(self):
        fake_info = {
            "format": {"duration": "N/A"},
            "streams": [{"duration": "N/A"}],
        }
        with mock.patch.object(media_probe, "get_video_info", return_value=fake_info):
            self.assertEqual(
                media_probe.get_media_duration_seconds("/fake.mp4", default=99.0),
                99.0,
            )

    def test_falls_back_when_probe_raises(self):
        with mock.patch.object(
            media_probe, "get_video_info", side_effect=RuntimeError("ffprobe failed")
        ):
            self.assertEqual(
                media_probe.get_media_duration_seconds("/fake.mp4", default=7.0),
                7.0,
            )


class HasAudioStreamTests(unittest.TestCase):
    def test_detects_audio(self):
        info = {"streams": [{"codec_type": "video"}, {"codec_type": "audio"}]}
        with mock.patch.object(media_probe, "get_video_info", return_value=info):
            self.assertTrue(media_probe.has_audio_stream("/fake.mp4"))

    def test_detects_no_audio(self):
        info = {"streams": [{"codec_type": "video"}]}
        with mock.patch.object(media_probe, "get_video_info", return_value=info):
            self.assertFalse(media_probe.has_audio_stream("/fake.mp4"))

    def test_assumes_yes_on_probe_failure(self):
        # Defensive default: pipeline should still try audio filters
        with mock.patch.object(
            media_probe, "get_video_info", side_effect=RuntimeError("boom")
        ):
            self.assertTrue(media_probe.has_audio_stream("/fake.mp4"))


class GetDimensionsTests(unittest.TestCase):
    def test_returns_first_video_stream_dimensions(self):
        info = {
            "streams": [
                {"codec_type": "audio"},
                {"codec_type": "video", "width": 1920, "height": 1080},
            ]
        }
        with mock.patch.object(media_probe, "get_video_info", return_value=info):
            self.assertEqual(
                media_probe.get_dimensions("/fake.mp4"), (1920, 1080)
            )

    def test_raises_when_no_video_stream(self):
        info = {"streams": [{"codec_type": "audio"}]}
        with mock.patch.object(media_probe, "get_video_info", return_value=info):
            with self.assertRaises(ValueError):
                media_probe.get_dimensions("/fake.mp4")


class VideoProcessorReExportsTests(unittest.TestCase):
    """Regression guard: video_processor must continue to expose the
    helpers under their original names so older imports and test mocks
    don't break."""

    def test_video_processor_reexports_helpers(self):
        from services import video_processor as vp
        self.assertIs(vp.get_video_info, media_probe.get_video_info)
        self.assertIs(vp.get_dimensions, media_probe.get_dimensions)
        self.assertIs(vp._has_audio_stream, media_probe.has_audio_stream)
        self.assertIs(
            vp._parse_duration_seconds, media_probe.parse_duration_seconds
        )
        self.assertIs(
            vp._get_media_duration_seconds, media_probe.get_media_duration_seconds
        )
        self.assertIs(
            vp._run_ffmpeg_with_fallback, media_probe.run_ffmpeg_with_fallback
        )

    def test_video_processor_still_exposes_cpu_flags_and_timeout(self):
        from services import video_processor as vp
        self.assertEqual(vp.CPU_FLAGS, media_probe.CPU_FLAGS)
        self.assertEqual(vp._FFMPEG_TIMEOUT, media_probe.FFMPEG_TIMEOUT)


class CpuFlagsAndTimeoutTests(unittest.TestCase):
    def test_cpu_flags_follow_podcli_quality(self):
        old = os.environ.get("PODCLI_QUALITY")
        try:
            os.environ["PODCLI_QUALITY"] = "max"
            flags = media_probe.cpu_flags()
            self.assertEqual(flags[flags.index("-crf") + 1], "14")
            self.assertEqual(flags[flags.index("-preset") + 1], "slower")
            os.environ["PODCLI_QUALITY"] = "high"
            flags = media_probe.cpu_flags()
            self.assertEqual(flags[flags.index("-crf") + 1], "18")
        finally:
            if old is None:
                os.environ.pop("PODCLI_QUALITY", None)
            else:
                os.environ["PODCLI_QUALITY"] = old

    def test_ffmpeg_timeout_scales_with_duration(self):
        self.assertEqual(media_probe.ffmpeg_timeout(), 300)
        self.assertGreater(media_probe.ffmpeg_timeout(40), 300)
        self.assertLessEqual(media_probe.ffmpeg_timeout(10_000), 1800)

    def test_stream_durations(self):
        info = {
            "streams": [
                {"codec_type": "video", "duration": "39.4"},
                {"codec_type": "audio", "duration": "32.8"},
            ]
        }
        with mock.patch.object(media_probe, "get_video_info", return_value=info):
            self.assertEqual(media_probe.stream_durations("/fake.mp4"), (39.4, 32.8))

    def test_align_av_skips_when_streams_agree(self):
        with mock.patch.object(media_probe, "stream_durations", return_value=(33.0, 32.95)):
            self.assertEqual(media_probe.align_av_duration("/fake.mp4"), "/fake.mp4")


if __name__ == "__main__":
    unittest.main()