Skip to content

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

5.4 KB
Raw Blame
"""Tests for backend.services.audio_analyzer.compute_energy_scores."""

import os
import sys
import tempfile
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 audio_analyzer as aa
from services import audio_extract


class ComputeEnergyScoresTests(unittest.TestCase):
    def test_empty_energy_data_returns_zeros(self):
        segments = [{"start": 0, "end": 10}, {"start": 10, "end": 20}]
        self.assertEqual(aa.compute_energy_scores([], segments), [0.0, 0.0])

    def test_all_silence_returns_zeros(self):
        # All values below -60 dB threshold → treated as silence
        energy = [{"time": t, "rms_db": -80} for t in range(0, 10)]
        self.assertEqual(
            aa.compute_energy_scores(energy, [{"start": 0, "end": 5}]), [0.0]
        )

    def test_empty_segments_returns_empty_list(self):
        self.assertEqual(aa.compute_energy_scores([{"time": 0, "rms_db": -20}], []), [])

    def test_higher_segment_energy_gets_higher_score(self):
        # Quiet baseline + one loud spike segment
        energy = []
        for t in range(0, 30):
            energy.append({"time": float(t), "rms_db": -30.0})
        # Loud spike in range 10-15
        for t in range(10, 16):
            energy.append({"time": float(t), "rms_db": -10.0})

        segments = [
            {"start": 0, "end": 5},     # quiet
            {"start": 10, "end": 15},   # loud
            {"start": 20, "end": 25},   # quiet
        ]
        scores = aa.compute_energy_scores(energy, segments)
        self.assertEqual(len(scores), 3)
        self.assertGreater(scores[1], scores[0])
        self.assertGreater(scores[1], scores[2])

    def test_scores_bounded_to_0_10(self):
        # Create data that might push scores out of range
        energy = [{"time": float(t), "rms_db": -30.0} for t in range(0, 50)]
        # One huge spike
        energy.append({"time": 25.0, "rms_db": 0.0})
        segments = [{"start": 24, "end": 26}]
        scores = aa.compute_energy_scores(energy, segments)
        self.assertGreaterEqual(scores[0], 0)
        self.assertLessEqual(scores[0], 10)

    def test_segment_outside_energy_window_gets_zero(self):
        energy = [{"time": float(t), "rms_db": -20.0} for t in range(0, 10)]
        segments = [{"start": 100, "end": 110}]  # completely outside data
        self.assertEqual(aa.compute_energy_scores(energy, segments), [0.0])

    def test_ignores_silence_samples_within_segment(self):
        # A segment with loud + silent samples should only score off the loud ones
        energy = [
            {"time": 0.0, "rms_db": -20.0},
            {"time": 1.0, "rms_db": -80.0},  # silence, should be ignored
            {"time": 2.0, "rms_db": -20.0},
            {"time": 3.0, "rms_db": -40.0},  # baseline context
            {"time": 4.0, "rms_db": -40.0},
        ]
        scores = aa.compute_energy_scores(energy, [{"start": 0, "end": 2}])
        # Only 2 samples contribute: -20 is above the -40 baseline → score > 0
        self.assertGreater(scores[0], 0)

    def test_zero_variance_energy_is_handled(self):
        # All-same energy level would cause std=0; function must avoid div-by-zero
        energy = [{"time": float(t), "rms_db": -25.0} for t in range(0, 20)]
        segments = [{"start": 5, "end": 10}]
        # Should not raise
        scores = aa.compute_energy_scores(energy, segments)
        self.assertEqual(len(scores), 1)



class ExtractAudioEnergyCommandTests(unittest.TestCase):
    def _run(self, wav_path=None):
        with mock.patch.object(aa, "proc_run", return_value=mock.Mock(returncode=0, stdout="", stderr="")) as mocked, \
             mock.patch.object(aa, "_fallback_energy", return_value=[]):
            aa.extract_audio_energy("/video.mp4", wav_path=wav_path)
        return mocked.call_args.args[0]

    def test_window_is_pinned_with_asetnsamples(self):
        cmd = self._run()
        af = cmd[cmd.index("-af") + 1]
        self.assertIn("asetnsamples=n=16000", af)
        self.assertIn("astats=metadata=1:reset=1", af)

    def test_uses_shared_wav_when_provided(self):
        fd, wav = tempfile.mkstemp(suffix=".wav")
        os.close(fd)
        try:
            cmd = self._run(wav_path=wav)
            self.assertIn(wav, cmd)
            self.assertNotIn("/video.mp4", cmd)
        finally:
            os.unlink(wav)

    def test_missing_wav_falls_back_to_video(self):
        cmd = self._run(wav_path="/no/such.wav")
        self.assertIn("/video.mp4", cmd)


class ExtractWavCleanupTests(unittest.TestCase):
    def test_failed_extraction_removes_internally_created_wav(self):
        with tempfile.TemporaryDirectory() as tmpdir:
            wav_path = os.path.join(tmpdir, "failed.wav")
            fd = os.open(wav_path, os.O_CREAT | os.O_RDWR)
            with mock.patch.object(
                audio_extract.tempfile,
                "mkstemp",
                return_value=(fd, wav_path),
            ), mock.patch.object(
                audio_extract,
                "proc_run",
                return_value=mock.Mock(returncode=1, stderr="ffmpeg failed"),
            ):
                with self.assertRaisesRegex(RuntimeError, "ffmpeg failed"):
                    audio_extract.extract_wav_16k_mono("/video.mp4")

            self.assertFalse(os.path.exists(wav_path))


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