Files
jellyfin-scene-search/tests/test_caption_editor.py
T

219 lines
9.7 KiB
Python

from __future__ import annotations
import tempfile
import unittest
from pathlib import Path
from unittest.mock import Mock
import numpy as np
from scene_search.caption_editor import captioned_media, correct_caption
from scene_search.database import connect, init_db, pack_vector
class CaptionEditorTests(unittest.TestCase):
def seed(self, db_path: Path) -> None:
init_db(db_path)
with connect(db_path) as con:
con.execute(
"""INSERT INTO media (
id, source_path, title, content_sha256, size_bytes,
mtime_ns, interval_ms, model_id, embedding_dim,
source_kind, jellyfin_item_id, jellyfin_library_id
) VALUES (
'm1', 'jellyfin://movie1', 'Some Movie', 'hash',
1, 0, 30000, 'model', 2, 'jellyfin',
'jf-1', 'library-1'
)"""
)
vector = pack_vector(np.asarray([1.0, 0.0], dtype=np.float32))
for n in range(3):
con.execute(
"""INSERT INTO frames (
id, media_id, frame_number, timestamp_ms,
thumb_path, embedding_f16, caption
) VALUES (?, 'm1', ?, ?, '', ?, ?)""",
(
f"f{n}", n, n * 30000, vector,
"Legacy caption for frame" if n == 2
else "Old member caption",
),
)
con.execute(
"""INSERT INTO caption_windows (
id, media_id, start_ms, end_ms,
representative_frame_id, caption, window_policy
) VALUES ('cw1', 'm1', 0, 60000, 'f0',
'Wrong colour on shirt', 'test-policy')"""
)
con.executemany(
"""INSERT INTO caption_window_frames
(window_id, frame_id, position) VALUES ('cw1', ?, ?)""",
[("f0", 0), ("f1", 1)],
)
def test_list_shows_canonical_windows_not_member_frame_captions(self) -> None:
with tempfile.TemporaryDirectory() as d:
db = Path(d) / "scenes.sqlite3"
self.seed(db)
first = captioned_media(db, "m1", limit=1)
self.assertEqual(first["media"]["title"], "Some Movie")
self.assertEqual(first["overview_status"], "none")
self.assertEqual(first["captions"][0]["kind"], "window")
self.assertEqual(first["captions"][0]["caption"], "Wrong colour on shirt")
self.assertTrue(first["has_more"])
second = captioned_media(db, "m1", offset=1, limit=1)
self.assertEqual(second["captions"][0]["kind"], "frame")
self.assertEqual(second["captions"][0]["caption"], "Legacy caption for frame")
self.assertFalse(second["has_more"])
def test_correct_window_updates_only_representative_frame_and_audits(self) -> None:
with tempfile.TemporaryDirectory() as d:
db = Path(d) / "scenes.sqlite3"
self.seed(db)
with connect(db) as con:
con.execute(
"""INSERT INTO jellyfin_overview_drafts (
media_id, jellyfin_item_id, overview, model,
caption_fingerprint, sampled_captions
) VALUES ('m1', 'jf-1', 'Outdated summary',
'model', 'hash', 2)"""
)
meili = Mock()
result = correct_caption(
db, kind="window", caption_id="cw1",
expected_caption="Wrong colour on shirt",
caption="A person wearing a blue shirt",
meili=meili,
)
self.assertTrue(result["synced"])
self.assertTrue(result["overview_draft_invalidated"])
self.assertFalse(result["overview_published"])
documents = meili.update_documents.call_args.args[0]
# Only one partial caption update; no vector or full-index rebuild.
self.assertEqual(len(documents), 1)
self.assertEqual(documents[0]["id"], "f0")
self.assertEqual(documents[0]["caption"], "A person wearing a blue shirt")
self.assertNotIn("_vectors", documents[0])
meili.update_documents.assert_called_once()
self.assertTrue(meili.update_documents.call_args.kwargs["wait"])
with connect(db) as con:
saved = con.execute("SELECT caption FROM caption_windows WHERE id = 'cw1'").fetchone()
audit = con.execute("SELECT * FROM caption_edit_history").fetchone()
draft_count = con.execute(
"SELECT COUNT(*) FROM jellyfin_overview_drafts"
).fetchone()[0]
sync = con.execute(
"SELECT meili_synced_at FROM frames WHERE id='f0'"
).fetchone()[0]
self.assertEqual(saved["caption"], "A person wearing a blue shirt")
self.assertEqual(audit["previous_caption"], "Wrong colour on shirt")
self.assertEqual(audit["corrected_caption"], saved["caption"])
self.assertEqual(draft_count, 0)
self.assertIsNotNone(sync)
self.assertTrue(captioned_media(db, "m1")["captions"][0]["manually_edited"])
def test_correct_legacy_frame_and_reject_window_members(self) -> None:
with tempfile.TemporaryDirectory() as d:
db = Path(d) / "scenes.sqlite3"
self.seed(db)
meili = Mock()
with self.assertRaises(LookupError):
correct_caption(
db, kind="frame", caption_id="f1",
expected_caption="Old member caption",
caption="Nope", meili=meili,
)
result = correct_caption(
db, kind="frame", caption_id="f2",
expected_caption="Legacy caption for frame",
caption="Corrected frame text", meili=meili,
)
self.assertTrue(result["changed"])
self.assertEqual(
meili.update_documents.call_args.args[0][0]["caption"],
"Corrected frame text",
)
def test_stale_save_and_empty_text_do_not_overwrite_original(self) -> None:
with tempfile.TemporaryDirectory() as d:
db = Path(d) / "scenes.sqlite3"
self.seed(db)
meili = Mock()
with self.assertRaisesRegex(RuntimeError, "changed since loading"):
correct_caption(
db, kind="window", caption_id="cw1",
expected_caption="Stale old text",
caption="New", meili=meili,
)
with self.assertRaisesRegex(ValueError, "cannot be empty"):
correct_caption(
db, kind="window", caption_id="cw1",
expected_caption="Wrong colour on shirt",
caption=" ", meili=meili,
)
with connect(db) as con:
self.assertEqual(
con.execute("SELECT COUNT(*) FROM caption_edit_history").fetchone()[0], 0,
)
meili.update_documents.assert_not_called()
def test_meili_failure_preserves_correction_for_later_catchup(self) -> None:
with tempfile.TemporaryDirectory() as d:
db = Path(d) / "scenes.sqlite3"
self.seed(db)
meili = Mock()
meili.update_documents.side_effect = RuntimeError("queue busy")
result = correct_caption(
db, kind="window", caption_id="cw1",
expected_caption="Wrong colour on shirt",
caption="Blue shirt", meili=meili,
)
self.assertFalse(result["synced"])
self.assertIn("queue busy", result["sync_error"])
with connect(db) as con:
self.assertEqual(
con.execute("SELECT caption FROM caption_windows").fetchone()[0],
"Blue shirt",
)
self.assertIsNone(
con.execute("SELECT meili_synced_at FROM frames WHERE id='f0'")
.fetchone()[0],
)
self.assertEqual(
con.execute("SELECT COUNT(*) FROM caption_edit_history").fetchone()[0],
1,
)
def test_published_overview_is_preserved(self) -> None:
with tempfile.TemporaryDirectory() as d:
db = Path(d) / "scenes.sqlite3"
self.seed(db)
with connect(db) as con:
con.execute(
"""INSERT INTO jellyfin_overview_drafts (
media_id, jellyfin_item_id, overview, model,
caption_fingerprint, sampled_captions,
original_overview, applied_overview, applied_at
) VALUES ('m1', 'jf-1', 'Old draft',
'model', 'hash', 2, 'Original',
'Original + AI', CURRENT_TIMESTAMP)"""
)
result = correct_caption(
db, kind="window", caption_id="cw1",
expected_caption="Wrong colour on shirt",
caption="Blue shirt", meili=Mock(),
)
self.assertTrue(result["overview_published"])
self.assertFalse(result["overview_draft_invalidated"])
with connect(db) as con:
applied = con.execute(
"SELECT applied_overview FROM jellyfin_overview_drafts"
).fetchone()[0]
self.assertEqual(applied, "Original + AI")
if __name__ == "__main__":
unittest.main()