File size: 5,624 Bytes
2636772
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
7562488
 
 
 
 
 
 
2636772
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
4b79268
2636772
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
import json
from pathlib import Path

import pytest
from PIL import Image

from app.pipeline.html_gen import (
    Segment,
    metadata_to_segment,
    render_from_metadata,
    render_guide,
)
from app.pipeline.metadata import (
    CURRENT_SCHEMA_VERSION,
    KeyTerm,
    MathEquation,
    PageMetadata,
    SegmentMetadata,
    dump_metadata,
    load_metadata,
    migrate_v1_to_v2,
    page_metadata_from_segments,
    segment_to_metadata,
)


def _make_image(path: Path) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    Image.new("RGB", (32, 24), (123, 200, 50)).save(path, "JPEG")


def _sample_segment(idx: int = 0) -> Segment:
    return Segment(
        index=idx,
        start_seconds=float(idx * 5),
        end_seconds=float(idx * 5 + 5),
        image_filename=f"scene_{idx:04d}.jpg",
        image_data_uri=None,
        narration=["First paragraph.", "Second paragraph."],
        ocr_text="ocr text",
        alt_draft="An image showing a slide.",
        section_title=f"Section {idx + 1}",
        key_terms=[KeyTerm(term="Photon", definition="A particle of light.")],
        math_equations=[
            MathEquation(latex="E=mc^2", aria_label="E equals m c squared"),
        ],
        include=True,
    )


def test_pagemetadata_roundtrips_through_json(tmp_path):
    page = page_metadata_from_segments(
        title="Round-Trip",
        segments=[_sample_segment(0), _sample_segment(1)],
        subtitle="A subtitle",
        module="Module 7",
        meta_lines=["2 segments", "Source: 0:10"],
    )
    out = tmp_path / "meta.json"
    dump_metadata(out, page)

    loaded = load_metadata(out)
    assert loaded.schema_version == CURRENT_SCHEMA_VERSION
    assert loaded.title == "Round-Trip"
    assert loaded.subtitle == "A subtitle"
    assert loaded.module == "Module 7"
    assert len(loaded.segments) == 2
    assert loaded.segments[0].key_terms[0].term == "Photon"
    assert loaded.segments[0].math_equations[0].latex == "E=mc^2"
    assert loaded.segments[0].narration == ["First paragraph.", "Second paragraph."]


def test_segment_to_and_from_metadata(tmp_path):
    seg = _sample_segment(3)
    seg_meta = segment_to_metadata(seg)
    assert isinstance(seg_meta, SegmentMetadata)
    assert seg_meta.index == 3
    assert seg_meta.alt_text == "An image showing a slide."
    assert seg_meta.key_terms[0].definition == "A particle of light."

    img = tmp_path / seg.image_filename
    _make_image(img)
    rebuilt = metadata_to_segment(seg_meta, tmp_path, inline_images=False)
    assert isinstance(rebuilt, Segment)
    assert rebuilt.section_title == seg.section_title
    assert rebuilt.alt_draft == seg.alt_draft
    assert rebuilt.narration == seg.narration


def test_migrate_v1_to_v2_fills_defaults():
    v1 = {
        "title": "Old Save",
        "eyebrow": "Legacy",
        "segments": [
            {
                "index": 0,
                "section_title": "Intro",
                "alt_text": "Slide",
                "narration": "Single string narration.",
                "ocr_text": "OCR",
                "include": True,
            }
        ],
    }
    v2 = migrate_v1_to_v2(v1)
    page = PageMetadata.model_validate(v2)
    assert page.schema_version == CURRENT_SCHEMA_VERSION
    assert page.subtitle is None
    assert page.module is None
    assert page.frames_dir == "frames"
    seg = page.segments[0]
    assert seg.narration == ["Single string narration."]
    assert seg.key_terms == []
    assert seg.math_equations == []
    assert seg.image_filename == "scene_0000.jpg"
    # Learner-feature fields (added later than the original v1→v2
    # migration spec) must still receive empty defaults so downstream
    # consumers of the raw migrated dict aren't surprised.
    assert v2["segments"][0]["summary"] == ""
    assert v2["segments"][0]["self_check_questions"] == []
    assert seg.summary == ""
    assert seg.self_check_questions == []


def test_migrate_v1_via_load_metadata_with_no_schema_version_key(tmp_path):
    v1_json = tmp_path / "v1.json"
    v1_json.write_text(
        json.dumps(
            {
                "title": "Old",
                "segments": [
                    {"index": 0, "narration": ["one", "two"], "section_title": "S", "alt_text": "A"}
                ],
            }
        ),
        encoding="utf-8",
    )
    page = load_metadata(v1_json)
    assert page.schema_version == CURRENT_SCHEMA_VERSION
    assert page.segments[0].narration == ["one", "two"]


def test_render_from_metadata_idempotent(tmp_path):
    img0 = tmp_path / "scene_0000.jpg"
    img1 = tmp_path / "scene_0001.jpg"
    _make_image(img0)
    _make_image(img1)

    page = page_metadata_from_segments(
        title="Idempotent",
        segments=[_sample_segment(0), _sample_segment(1)],
        subtitle="Sub",
        module="Mod 3",
    )
    page.frames_dir = str(tmp_path)

    html_a = render_from_metadata(page, frames_dir=tmp_path, mode="single")
    html_b = render_from_metadata(page, frames_dir=tmp_path, mode="single")
    assert html_a == html_b
    assert "Idempotent" in html_a


def test_render_from_metadata_links_images_in_guide_mode(tmp_path):
    img0 = tmp_path / "scene_0000.jpg"
    _make_image(img0)
    page = page_metadata_from_segments(
        title="Linked",
        segments=[_sample_segment(0)],
    )
    page.frames_dir = str(tmp_path)
    html = render_from_metadata(page, frames_dir=tmp_path, mode="guide")
    # In guide mode (non-inline), images are referenced by path.
    assert 'src="static/scene_0000.jpg"' in html
    assert "data:image/jpeg;base64," not in html