Skip to content

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

6.6 KB
Raw Blame
"""Tests for pure helper functions inside video_processor.

Deliberately tests only the side-effect-free helpers (keyframe
simplification, speaker-side resolution, face track assignment) so
the suite can run without cv2, ffmpeg, or real video files.
"""

import os
import sys
import unittest

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 video_processor as vp


class SimplifyKeyframesTests(unittest.TestCase):
    def test_short_input_is_unchanged(self):
        self.assertEqual(vp._simplify_keyframes([]), [])
        self.assertEqual(vp._simplify_keyframes([(0, 100)]), [(0, 100)])
        self.assertEqual(
            vp._simplify_keyframes([(0, 100), (5, 200)]),
            [(0, 100), (5, 200)],
        )

    def test_collinear_points_dropped(self):
        # Perfect line: (0,0) → (5,500) → (10,1000) → middle should drop
        keyframes = [(0, 0), (5, 500), (10, 1000)]
        out = vp._simplify_keyframes(keyframes)
        self.assertEqual(out, [(0, 0), (10, 1000)])

    def test_non_collinear_points_preserved(self):
        # (0,0), (5,800), (10,1000), middle is far from the interpolated value
        keyframes = [(0, 0), (5, 800), (10, 1000)]
        out = vp._simplify_keyframes(keyframes)
        self.assertEqual(out, keyframes)  # all preserved

    def test_tolerance_controls_sensitivity(self):
        # Middle point is 10 units off the line
        keyframes = [(0, 0), (5, 510), (10, 1000)]
        # With loose tolerance, it's dropped
        loose = vp._simplify_keyframes(keyframes, tolerance=50)
        self.assertEqual(loose, [(0, 0), (10, 1000)])
        # With tight tolerance, it's kept
        tight = vp._simplify_keyframes(keyframes, tolerance=1)
        self.assertEqual(tight, keyframes)

    def test_always_keeps_endpoints(self):
        keyframes = [(0, 100), (1, 100), (2, 100), (3, 100)]
        out = vp._simplify_keyframes(keyframes)
        # At minimum first and last survive
        self.assertEqual(out[0], (0, 100))
        self.assertEqual(out[-1], (3, 100))


class ResolveSpeakerSidesTests(unittest.TestCase):
    def test_no_face_map_returns_empty(self):
        # Without a face_map, we cannot infer sides; must return empty dict
        sides = vp._resolve_speaker_sides(
            segments=[(0.0, 5.0, "SPEAKER_00")],
            detections=[],
            width=1920,
            face_map=None,
        )
        self.assertEqual(sides, {})

    def test_face_map_assigns_sides_based_on_cluster_x(self):
        face_map = {
            "clusters": [
                {"center_x": 400},   # left of 960 midline
                {"center_x": 1500},  # right of midline
            ],
            "speaker_mappings": {
                "SPEAKER_00": 0,
                "SPEAKER_01": 1,
            },
        }
        sides = vp._resolve_speaker_sides(
            segments=[],
            detections=[],
            width=1920,
            face_map=face_map,
        )
        self.assertEqual(sides["SPEAKER_00"], "left")
        self.assertEqual(sides["SPEAKER_01"], "right")

    def test_ignores_unmapped_speakers(self):
        face_map = {
            "clusters": [{"center_x": 400}],
            "speaker_mappings": {
                "SPEAKER_00": 0,
                "SPEAKER_GHOST": None,   # unmapped
                "SPEAKER_OOB": 99,       # index out of range
            },
        }
        sides = vp._resolve_speaker_sides(
            segments=[], detections=[], width=1920, face_map=face_map,
        )
        self.assertEqual(sides, {"SPEAKER_00": "left"})


class AssignFaceTracksTests(unittest.TestCase):
    def test_empty_detections(self):
        self.assertEqual(vp._assign_face_tracks([], width=1920), [])

    def test_stable_face_gets_stable_track_id(self):
        # Same face position across frames → same track id
        detections = [
            (0.0, [{"cx": 500, "fw": 120}]),
            (0.2, [{"cx": 505, "fw": 120}]),
            (0.4, [{"cx": 510, "fw": 120}]),
        ]
        tracked = vp._assign_face_tracks(detections, width=1920)
        self.assertEqual(len(tracked), 3)
        # All three frames should share one track id
        ids = set()
        for _t, faces in tracked:
            for f in faces:
                ids.add(f.get("track_id"))
        self.assertEqual(len(ids), 1)

    def test_distant_faces_get_different_track_ids(self):
        # Two clearly separated faces on opposite sides
        detections = [
            (0.0, [{"cx": 300, "fw": 120}, {"cx": 1500, "fw": 120}]),
            (0.2, [{"cx": 305, "fw": 120}, {"cx": 1495, "fw": 120}]),
        ]
        tracked = vp._assign_face_tracks(detections, width=1920)
        # Frame 0 should have 2 distinct track ids
        frame0_ids = {f["track_id"] for f in tracked[0][1]}
        self.assertEqual(len(frame0_ids), 2)
        # Frame 1's ids should match frame 0's (stable)
        frame1_ids = {f["track_id"] for f in tracked[1][1]}
        self.assertEqual(frame0_ids, frame1_ids)



class FaceSampleIndicesTests(unittest.TestCase):
    def _reference_indices(self, total_frames, fps):
        """The stepping the old cap.set() sampling loop used."""
        sample_step = max(1, int(fps / 10))
        dense_end = int(fps * 0.5)
        semi_dense_end = int(fps * 1.0)
        semi_dense_step = max(1, sample_step // 2)
        indices = []
        idx = 0
        while idx < total_frames:
            indices.append(idx)
            if idx < dense_end:
                idx += 1
            elif idx < semi_dense_end:
                idx += semi_dense_step
            else:
                idx += sample_step
        return indices

    def test_matches_seek_loop_progression_at_30fps(self):
        self.assertEqual(vp._face_sample_indices(300, 30.0), self._reference_indices(300, 30.0))

    def test_matches_seek_loop_progression_at_60fps(self):
        self.assertEqual(vp._face_sample_indices(600, 60.0), self._reference_indices(600, 60.0))

    def test_dense_start_then_sparse(self):
        indices = vp._face_sample_indices(900, 30.0)
        self.assertEqual(indices[:15], list(range(15)))
        steps = {b - a for a, b in zip(indices, indices[1:]) if a >= 30}
        self.assertEqual(steps, {3})

    def test_strictly_increasing_and_bounded(self):
        indices = vp._face_sample_indices(100, 24.0)
        self.assertEqual(indices, sorted(set(indices)))
        self.assertLess(indices[-1], 100)

    def test_empty_video(self):
        self.assertEqual(vp._face_sample_indices(0, 30.0), [])


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