learnx-cli 0.3.0__py3-none-any.whl

tutor/tests/visual/test_slide_renderer.py

@@ -0,0 +1,298 @@
+from pathlib import Path
+
+import pytest
+from jinja2 import TemplateNotFound
+
+from tutor.models import SlideSegment, VisualSpec
+from tutor.visual.slide_renderer import _render_html, render_all_slides
+
+# ── Fixtures ─────────────────────────────────────────────────────────────────
+
+
+def _make_seg(
+    unit_index: int = 1,
+    segment_index: int = 0,
+    visual_type: str = "key_insight",
+    title: str = "Test Slide",
+    **kwargs: object,
+) -> SlideSegment:
+    return SlideSegment(
+        unit_index=unit_index,
+        segment_index=segment_index,
+        lines_start=0,
+        lines_end=1,
+        visual_type=visual_type,
+        title=title,
+        body=kwargs.get("body", "Some body text"),  # type: ignore[arg-type]
+        code=kwargs.get("code"),  # type: ignore[arg-type]
+        language=kwargs.get("language"),  # type: ignore[arg-type]
+        mermaid=kwargs.get("mermaid"),  # type: ignore[arg-type]
+        left=kwargs.get("left"),  # type: ignore[arg-type]
+        right=kwargs.get("right"),  # type: ignore[arg-type]
+        rows=kwargs.get("rows"),  # type: ignore[arg-type]
+    )
+
+
+def _make_spec(title: str = "Test Tutorial", subtitle: str = "Subtitle") -> VisualSpec:
+    return VisualSpec(unit_index=0, slide_type="title_card", title=title, subtitle=subtitle)
+
+
+def _make_segments_by_unit() -> dict[int, list[SlideSegment]]:
+    return {
+        1: [
+            _make_seg(unit_index=1, segment_index=0, visual_type="hook_question"),
+            _make_seg(unit_index=1, segment_index=1, visual_type="definition"),
+            _make_seg(unit_index=1, segment_index=2, visual_type="key_insight"),
+        ],
+        2: [
+            _make_seg(unit_index=2, segment_index=0, visual_type="hook_question"),
+            _make_seg(unit_index=2, segment_index=1, visual_type="memory_hook"),
+            _make_seg(unit_index=2, segment_index=2, visual_type="key_insight"),
+        ],
+    }
+
+
+# ── Non-browser tests ─────────────────────────────────────────────────────────
+
+
+def test_render_html_returns_string() -> None:
+    seg = _make_seg(visual_type="key_insight", body="Remember this!")
+    result = _render_html("key_insight", seg=seg, current_dot=1, total_dots=3)
+    assert isinstance(result, str)
+    assert len(result) > 0
+    assert "html" in result.lower()
+
+
+def test_template_missing_raises_clearly() -> None:
+    seg = _make_seg()
+    with pytest.raises(TemplateNotFound):
+        _render_html("nonexistent_type", seg=seg)
+
+
+# ── Browser tests (slow) ──────────────────────────────────────────────────────
+
+
+@pytest.mark.slow
+def test_render_all_slides_returns_correct_count(tmp_path: Path) -> None:
+    # 2 units × 3 segments + title + outro = 8 paths
+    title_spec = _make_spec("My Tutorial")
+    outro_spec = _make_spec("Thanks!", "See you next time")
+    segs = _make_segments_by_unit()
+    paths = render_all_slides(title_spec, outro_spec, segs, tmp_path / "slides", "test")
+    assert len(paths) == 8
+
+
+@pytest.mark.slow
+def test_title_is_first_path(tmp_path: Path) -> None:
+    title_spec = _make_spec()
+    outro_spec = _make_spec("Outro")
+    paths = render_all_slides(
+        title_spec, outro_spec, _make_segments_by_unit(), tmp_path / "slides", "test"
+    )
+    assert paths[0].name.startswith("00_title")
+
+
+@pytest.mark.slow
+def test_outro_is_last_path(tmp_path: Path) -> None:
+    title_spec = _make_spec()
+    outro_spec = _make_spec("Outro")
+    paths = render_all_slides(
+        title_spec, outro_spec, _make_segments_by_unit(), tmp_path / "slides", "test"
+    )
+    assert paths[-1].name.startswith("99_outro")
+
+
+@pytest.mark.slow
+def test_png_path_populated_on_segments(tmp_path: Path) -> None:
+    title_spec = _make_spec()
+    outro_spec = _make_spec("Outro")
+    segs_by_unit = _make_segments_by_unit()
+    render_all_slides(title_spec, outro_spec, segs_by_unit, tmp_path / "slides", "test")
+    for unit_segs in segs_by_unit.values():
+        for seg in unit_segs:
+            assert seg.png_path != ""
+
+
+@pytest.mark.slow
+def test_output_files_exist_on_disk(tmp_path: Path) -> None:
+    title_spec = _make_spec()
+    outro_spec = _make_spec("Outro")
+    paths = render_all_slides(
+        title_spec, outro_spec, _make_segments_by_unit(), tmp_path / "slides", "test"
+    )
+    for p in paths:
+        assert p.exists(), f"Missing: {p}"
+
+
+@pytest.mark.slow
+def test_image_dimensions_are_1920x1080(tmp_path: Path) -> None:
+    from PIL import Image  # noqa: PLC0415
+
+    title_spec = _make_spec()
+    outro_spec = _make_spec("Outro")
+    paths = render_all_slides(
+        title_spec, outro_spec, _make_segments_by_unit(), tmp_path / "slides", "test"
+    )
+    for p in paths:
+        img = Image.open(p)
+        assert img.size == (1920, 1080), f"{p.name}: expected 1920×1080, got {img.size}"
+
+
+def test_screenshot_uses_file_url_not_set_content(tmp_path: Path) -> None:
+    """_screenshot must call page.goto with a file:// URL, never page.set_content."""
+    from unittest.mock import MagicMock, patch
+
+    from tutor.visual.slide_renderer import _screenshot
+
+    mock_page = MagicMock()
+    out = tmp_path / "out.png"
+
+    def fake_screenshot(**kwargs: object) -> None:
+        out.write_bytes(b"PNG" + b"\x00" * 6000)
+
+    mock_page.screenshot.side_effect = fake_screenshot
+
+    with (
+        patch("tutor.visual.slide_renderer.tempfile.NamedTemporaryFile") as mock_ntf,
+        patch("tutor.visual.slide_renderer.os.unlink"),
+    ):
+        mock_file = MagicMock()
+        mock_file.__enter__ = lambda s: s
+        mock_file.__exit__ = MagicMock(return_value=False)
+        mock_file.name = str(tmp_path / "tmp.html")
+        mock_ntf.return_value = mock_file
+        _screenshot(mock_page, "<html></html>", out, False, False)
+
+    mock_page.goto.assert_called_once()
+    call_url = mock_page.goto.call_args[0][0]
+    assert call_url.startswith("file:///")
+    mock_page.set_content.assert_not_called()
+
+
+def test_tmp_file_cleaned_up_after_screenshot(tmp_path: Path) -> None:
+    """Temp HTML file must be deleted even if screenshot succeeds."""
+    import os
+    from unittest.mock import MagicMock
+
+    from tutor.visual.slide_renderer import _screenshot
+
+    recorded: list[str] = []
+
+    mock_page = MagicMock()
+    out = tmp_path / "out.png"
+
+    def fake_screenshot(**kwargs: object) -> None:
+        out.write_bytes(b"PNG" + b"\x00" * 6000)
+
+    mock_page.screenshot.side_effect = fake_screenshot
+
+    original_unlink = os.unlink
+
+    def tracking_unlink(path: str) -> None:
+        recorded.append(path)
+        try:
+            original_unlink(path)
+        except OSError:
+            pass
+
+    import tutor.visual.slide_renderer as sr
+
+    original = sr.os.unlink
+    sr.os.unlink = tracking_unlink  # type: ignore[assignment]
+    try:
+        _screenshot(mock_page, "<html></html>", out, False, False)
+    finally:
+        sr.os.unlink = original  # type: ignore[assignment]
+
+    assert len(recorded) == 1
+    assert recorded[0].endswith(".html")
+
+
+# ── Hardening tests (Day 4) ───────────────────────────────────────────────────
+
+
+def test_fallback_segment_reclassifies_to_key_insight() -> None:
+    from tutor.visual.slide_renderer import _fallback_segment
+
+    seg = _make_seg(visual_type="diagram", mermaid="classDiagram\n  A <|-- B")
+    result = _fallback_segment(seg)
+    assert result.visual_type == "key_insight"
+    assert result.mermaid is None
+    assert result.body is not None
+
+
+def test_fallback_segment_preserves_body_when_present() -> None:
+    from tutor.visual.slide_renderer import _fallback_segment
+
+    seg = _make_seg(body="Animal is a base class")
+    result = _fallback_segment(seg)
+    assert result.body == "Animal is a base class"
+
+
+def test_fallback_segment_uses_title_when_body_is_none() -> None:
+    from tutor.visual.slide_renderer import _fallback_segment
+
+    seg = _make_seg(title="Class hierarchy", body=None)
+    result = _fallback_segment(seg)
+    assert "Class hierarchy" in result.body  # type: ignore[operator]
+
+
+def test_min_png_bytes_constant() -> None:
+    from tutor.visual.slide_renderer import _MIN_PNG_BYTES
+
+    assert _MIN_PNG_BYTES == 5_120
+
+
+def test_screenshot_raises_on_small_file(tmp_path: Path) -> None:
+    """_screenshot raises RuntimeError when the output PNG is below the size threshold."""
+    from unittest.mock import MagicMock
+
+    from tutor.visual.slide_renderer import _screenshot
+
+    output = tmp_path / "test.png"
+    output.write_bytes(b"X")  # 1 byte — below threshold
+
+    mock_page = MagicMock()
+
+    with pytest.raises(RuntimeError, match="too small"):
+        _screenshot(
+            mock_page, "<html><body>test</body></html>", output, wait_mermaid=False, wait_hljs=False
+        )
+
+
+def test_screenshot_goto_retries_once_on_failure(tmp_path: Path) -> None:
+    """page.goto() is retried once before raising on persistent failure."""
+    from unittest.mock import MagicMock
+
+    from tutor.visual.slide_renderer import _screenshot
+
+    output = tmp_path / "out.png"
+    mock_page = MagicMock()
+    mock_page.goto.side_effect = [RuntimeError("connection reset"), None]
+
+    def fake_screenshot(**kwargs: object) -> None:
+        output.write_bytes(b"PNG" + b"\x00" * 6000)
+
+    mock_page.screenshot.side_effect = fake_screenshot
+
+    _screenshot(
+        mock_page, "<html><body>test</body></html>", output, wait_mermaid=False, wait_hljs=False
+    )
+    assert mock_page.goto.call_count == 2
+
+
+@pytest.mark.slow
+def test_invalid_mermaid_does_not_crash(tmp_path: Path) -> None:
+    title_spec = _make_spec()
+    outro_spec = _make_spec("Outro")
+    bad_diagram = _make_seg(
+        unit_index=1,
+        segment_index=0,
+        visual_type="diagram",
+        mermaid="this is not valid mermaid @@##!!",
+    )
+    segs = {1: [bad_diagram]}
+    paths = render_all_slides(title_spec, outro_spec, segs, tmp_path / "slides", "test")
+    diagram_path = next((p for p in paths if "diagram" in p.name), None)
+    assert diagram_path is not None
+    assert diagram_path.exists()

tutor/tests/visual/test_subtitle_writer.py

@@ -0,0 +1,165 @@
+import re
+
+import pytest
+
+from tutor.models import DialogueLine
+from tutor.visual.subtitle_writer import (
+    _format_timestamp,
+    _line_duration,
+    _wrap_subtitle,
+    build_srt,
+    get_line_start_offsets,
+)
+
+
+def _line(speaker: str, text: str, unit: int = 1) -> DialogueLine:
+    return DialogueLine(speaker=speaker, text=text, unit_number=unit)
+
+
+# ── SRT format ───────────────────────────────────────────────────────────────
+
+
+def test_srt_numbering_sequential():
+    lines = [
+        _line("ALEX", "Hello world", 1),
+        _line("MAYA", "Great point", 1),
+        _line("ALEX", "Indeed", 1),
+    ]
+    srt = build_srt(lines, [30.0])
+    numbers = re.findall(r"^(\d+)$", srt, re.MULTILINE)
+    assert numbers == ["1", "2", "3"]
+
+
+def test_timestamp_format_correct():
+    result = _format_timestamp(83.456)
+    assert result == "00:01:23,456"
+
+
+def test_timestamp_zero():
+    assert _format_timestamp(0.0) == "00:00:00,000"
+
+
+def test_timestamp_hours():
+    assert _format_timestamp(3661.5) == "01:01:01,500"
+
+
+# ── Subtitle wrapping ─────────────────────────────────────────────────────────
+
+
+def test_line_wrap_at_60_chars():
+    short = _wrap_subtitle("ALEX", "Short text.")
+    assert len(short) <= 60
+    assert "\n" not in short
+
+
+def test_line_wrap_long_text_splits():
+    long_text = (
+        "This is an extremely long piece of dialogue that definitely exceeds sixty characters"
+    )
+    result = _wrap_subtitle("MAYA", long_text)
+    for segment in result.split("\n"):
+        assert len(segment) <= 60
+
+
+def test_wrap_preserves_speaker():
+    result = _wrap_subtitle("SAM", "Hello world")
+    assert result.startswith("SAM: ")
+
+
+# ── Unit duration scaling ─────────────────────────────────────────────────────
+
+
+def test_unit_scaling_when_duration_mismatch():
+    lines = [
+        _line("ALEX", "One two three four five six seven eight nine ten", 1),
+        _line("MAYA", "One two three four five six seven eight nine ten", 1),
+    ]
+    estimated = sum(_line_duration(ln.text) for ln in lines)
+    # Supply actual = 150% of estimated — should scale up
+    actual_s = estimated * 1.5
+    _srt = build_srt(lines, [actual_s])
+    offsets = get_line_start_offsets(lines, [actual_s])
+    # The second line's start should be later than without scaling
+    offsets_noscale = get_line_start_offsets(lines, [estimated])
+    assert offsets[1] > offsets_noscale[1]
+
+
+def test_no_scaling_within_10_percent():
+    lines = [_line("ALEX", "Short line", 1)]
+    estimated = _line_duration(lines[0].text)
+    actual = estimated * 1.08  # 8% difference, below threshold
+    offsets_scaled = get_line_start_offsets(lines, [actual])
+    offsets_exact = get_line_start_offsets(lines, [estimated])
+    assert offsets_scaled[0] == offsets_exact[0]
+
+
+# ── Offset consistency ────────────────────────────────────────────────────────
+
+
+def test_get_line_start_offsets_matches_srt_timestamps():
+    lines = [
+        _line("ALEX", "First line here now", 1),
+        _line("MAYA", "Second line here now", 1),
+    ]
+    unit_dur = [30.0]
+    offsets = get_line_start_offsets(lines, unit_dur)
+    srt = build_srt(lines, unit_dur)
+
+    # Extract first timestamp from SRT
+    match = re.search(r"(\d{2}:\d{2}:\d{2},\d{3}) -->", srt)
+    assert match
+    ts_str = match.group(1)
+    # First line always starts at 0.0
+    assert offsets[0] == 0.0
+    assert ts_str == "00:00:00,000"
+
+
+# ── Exact timing tests ────────────────────────────────────────────────────────
+
+
+def _make_timing_json(unit_num: int, entries: list[dict]) -> dict:
+    return {"version": 1, "units": {str(unit_num): entries}}
+
+
+def test_exact_offsets_from_timing_json() -> None:
+
+    lines = [_line("ALEX", "First line", 1)]
+    timing_json = _make_timing_json(1, [{"line_index": 0, "start_ms": 2000, "end_ms": 4000}])
+    offsets = get_line_start_offsets(lines, [30.0], timing_json)
+    # unit_start[1] = 0 + 2000ms/1000 = 2.0 s
+    assert offsets[0] == pytest.approx(2.0, abs=0.01)
+
+
+def test_fallback_when_timing_absent() -> None:
+    lines = [_line("ALEX", "Hello world", 1), _line("MAYA", "Great", 1)]
+    offsets_v2 = get_line_start_offsets(lines, [30.0])
+    offsets_v3 = get_line_start_offsets(lines, [30.0], None)
+    assert offsets_v2 == offsets_v3
+
+
+def test_inter_unit_silence_included() -> None:
+    from tutor.constants import SILENCE_UNIT_MS  # noqa: PLC0415
+
+    unit1_dur = 20.0
+    lines = [_line("ALEX", "Unit one", 1), _line("ALEX", "Unit two", 2)]
+    timing_json = {
+        "version": 1,
+        "units": {
+            "1": [{"line_index": 0, "start_ms": 0, "end_ms": 1000}],
+            "2": [{"line_index": 0, "start_ms": 0, "end_ms": 1000}],
+        },
+    }
+    offsets = get_line_start_offsets(lines, [unit1_dur, 20.0], timing_json)
+    # unit_start[2] = unit1_dur + SILENCE_UNIT_MS/1000
+    expected = unit1_dur + SILENCE_UNIT_MS / 1000
+    assert offsets[1] == pytest.approx(expected, abs=0.01)
+
+
+def test_intro_lines_fall_back_to_estimation() -> None:
+    # Lines with unit_number=0 are not in timing_json → WPM estimation
+    lines = [_line("ALEX", "Intro text here", 0), _line("ALEX", "Unit one content", 1)]
+    timing_json = _make_timing_json(1, [{"line_index": 0, "start_ms": 5000, "end_ms": 6000}])
+    offsets_exact = get_line_start_offsets(lines, [30.0], timing_json)
+    offsets_wpm = get_line_start_offsets(lines, [30.0], None)
+    # Intro line (unit 0) uses WPM: offset should equal the WPM result
+    assert offsets_exact[0] == pytest.approx(offsets_wpm[0], abs=0.01)

tutor/tests/visual/test_video_assembler.py

@@ -0,0 +1,108 @@
+import subprocess
+
+import pytest
+
+import tutor.visual.video_assembler as va
+from tutor.exceptions import VideoError
+
+
+def test_concat_script_written_correctly(tmp_path):
+    entries = [
+        (tmp_path / "01_hook.png", 6.31),
+        (tmp_path / "01_concept.png", 38.44),
+        (tmp_path / "01_memory.png", 9.25),
+    ]
+    script = tmp_path / "test.concat.txt"
+    va._write_concat_script(entries, script)
+
+    content = script.read_text(encoding="utf-8")
+    assert "ffconcat version 1.0" in content
+    assert "duration 6.310" in content
+    assert "duration 38.440" in content
+    # Last file appears twice (no duration on second appearance)
+    lines = content.strip().splitlines()
+    # Path is normalised to forward slashes in the concat script
+    expected_path = str(entries[-1][0].resolve()).replace("\\", "/")
+    assert lines[-1] == f"file '{expected_path}'"
+    assert "duration" not in lines[-1]
+
+
+def test_ffmpeg_called_with_yuv420p(tmp_path, monkeypatch):
+    captured = []
+
+    def mock_run(args, **kwargs):
+        captured.append(args)
+        return subprocess.CompletedProcess(args, 0, b"", b"")
+
+    monkeypatch.setattr(subprocess, "run", mock_run)
+
+    slides_with_dur = [(tmp_path / "01_hook.png", 5.0)]
+    mp3 = tmp_path / "unit_01.mp3"
+    mp3.touch()
+    output = tmp_path / "unit_01.mp4"
+
+    va._build_unit_video(slides_with_dur, mp3, output)
+
+    assert captured, "subprocess.run was not called"
+    assert "-pix_fmt" in captured[0]
+    yuv_idx = captured[0].index("-pix_fmt")
+    assert captured[0][yuv_idx + 1] == "yuv420p"
+
+
+def test_run_ffmpeg_raises_on_nonzero_exit(monkeypatch):
+    def failing_run(args, **kwargs):
+        return subprocess.CompletedProcess(args, 1, b"", b"some error")
+
+    monkeypatch.setattr(subprocess, "run", failing_run)
+
+    with pytest.raises(VideoError, match="ffmpeg failed"):
+        va._run_ffmpeg(["ffmpeg", "-version"])
+
+
+def test_run_ffmpeg_no_error_on_success(monkeypatch):
+    monkeypatch.setattr(
+        subprocess, "run", lambda args, **kw: subprocess.CompletedProcess(args, 0, b"", b"")
+    )
+    va._run_ffmpeg(["ffmpeg", "-version"])  # should not raise
+
+
+def test_output_paths_in_video_dir(tmp_path):
+    audio_dir = tmp_path / "audio" / "week2_3" / "tutorial_units"
+    audio_dir.mkdir(parents=True)
+    video_dir = tmp_path / "video" / "week2_3"
+    video_dir.mkdir(parents=True)
+
+    # Verify _write_concat_script output is relative to video_dir, not audio_dir
+    entries = [(video_dir / "slides" / "01_hook.png", 5.0)]
+    script = video_dir / "unit_01.concat.txt"
+    va._write_concat_script(entries, script)
+
+    content = script.read_text()
+    # No reference to audio dir in concat script
+    assert str(audio_dir) not in content
+
+
+def test_concat_unit_videos_re_encodes_audio(tmp_path):
+    """_concat_unit_videos must NOT use bare -c copy — audio must be re-encoded."""
+    import inspect
+
+    from tutor.visual.video_assembler import _concat_unit_videos
+
+    src = inspect.getsource(_concat_unit_videos)
+    assert '"-c", "copy"' not in src, (
+        "_concat_unit_videos must re-encode audio (use -c:v copy + -c:a aac), "
+        "not bare -c copy, to fix timestamp discontinuities after concat"
+    )
+    assert '"-c:a", "aac"' in src
+
+
+def test_concat_script_single_entry(tmp_path):
+    entries = [(tmp_path / "only_slide.png", 4.0)]
+    script = tmp_path / "single.concat.txt"
+    va._write_concat_script(entries, script)
+
+    content = script.read_text()
+    lines = [ln for ln in content.strip().splitlines() if ln.startswith("file")]
+    # Single entry repeated twice
+    assert len(lines) == 2
+    assert lines[0] == lines[1]