chore: sprint cleanup — language unification, parser unification, fossils removal

Several weeks of work accumulated without being committed. Grouped here for clarity; see CHANGELOG.md [Unreleased] for the user-facing summary. Highlights ---------- P1 #2 — ISO 639-2/B canonical migration - New Language VO + LanguageRegistry (alfred/domain/shared/knowledge/). - iso_languages.yaml as single source of truth for language codes. - SubtitleKnowledgeBase now delegates lookup to LanguageRegistry; subtitles.yaml only declares subtitle-specific tokens (vostfr, vf, vff, …). - SubtitlePreferences default → ["fre", "eng"]; subtitle filenames written as {iso639_2b}.srt (legacy fr.srt still read via alias). - Scanner: dropped _LANG_KEYWORDS / _SDH_TOKENS / _FORCED_TOKENS / SUBTITLE_EXTENSIONS hardcoded dicts. - Fixed: 'hi' token no longer marks SDH (conflicted with Hindi alias). - Added settings.min_movie_size_bytes (was a module constant). P1 #3 — Release parser unification + data-driven tokenizer - parse_release() is now the single source of truth for release-name parsing. - alfred/knowledge/release/separators.yaml declares the token separators used by the tokenizer (., space, [, ], (, ), _). New conventions can be added without code changes. - Tokenizer now splits on any configured separator instead of name.split('.'). Releases like 'The Father (2020) [1080p] [WEBRip] [5.1] [YTS.MX]' parse via the direct path without sanitization fallback. - Site-tag extraction always runs first; well-formedness only rejects truly forbidden chars. - _parse_season_episode() extended with NxNN / NxNNxNN alt forms. - Removed dead helpers: _sanitize, _normalize. Domain cleanup - Deleted fossil services with zero production callers: alfred/domain/movies/services.py alfred/domain/tv_shows/services.py alfred/domain/subtitles/services.py (replaced by subtitles/services/ package) alfred/domain/subtitles/repositories.py - Split monolithic subtitle services into a package (identifier, matcher, placer, pattern_detector, utils) + dedicated knowledge/ package. - MediaInfo split into dedicated package (alfred/domain/shared/media/: audio, video, subtitle, info, matching). Persistence cleanup - Removed dead JSON repositories (movie/subtitle/tvshow_repository.py). Tests - Major expansion of the test suite organized to mirror the source tree. - Removed obsolete *_edge_cases test files superseded by structured tests. - Suite: 990 passed, 8 skipped. Misc - .gitignore: exclude env_backup/ and *.bak. - Adjustments across agent/llm, app.py, application/filesystem, and infrastructure/filesystem to align with the new domain layout.
2026-05-17 23:38:00 +02:00
parent ba6f016d49
commit e07c9ec77b
99 changed files with 8833 additions and 6533 deletions
@@ -0,0 +1,277 @@
+"""Tests for subtitle value objects, entities, and the ``utils`` service.
+
+Targets the quick-win surface of the subtitle domain that was largely
+uncovered:
+
+- ``TestSubtitleFormat`` — extension matching (case-insensitive).
+- ``TestSubtitleLanguage`` — token matching (case-insensitive).
+- ``TestSubtitleCandidateDestName`` — ``destination_name`` property:
+  standard / SDH / forced naming, error on missing language or format.
+- ``TestSubtitleCandidateRepr`` — debug repr for embedded vs external.
+- ``TestMediaSubtitleMetadata`` — ``all_tracks`` / ``total_count`` /
+  ``unresolved_tracks``.
+- ``TestAvailableSubtitles`` — utility dedup by (lang, type).
+- ``TestSubtitleRuleSet`` — scope inheritance + ``override`` mutation +
+  ``to_dict`` shape.
+
+All pure-Python — no I/O.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+from alfred.domain.subtitles.aggregates import SubtitleRuleSet
+from alfred.domain.subtitles.entities import MediaSubtitleMetadata, SubtitleCandidate
+from alfred.domain.subtitles.services.utils import available_subtitles
+from alfred.domain.subtitles.value_objects import (
+    RuleScope,
+    SubtitleFormat,
+    SubtitleLanguage,
+    SubtitleType,
+)
+
+# --------------------------------------------------------------------------- #
+# Value objects                                                                #
+# --------------------------------------------------------------------------- #
+
+
+class TestSubtitleFormat:
+    def test_matches_extension_case_insensitive(self):
+        fmt = SubtitleFormat(id="srt", extensions=[".srt"])
+        assert fmt.matches_extension(".srt")
+        assert fmt.matches_extension(".SRT")
+        assert not fmt.matches_extension(".ass")
+
+    def test_multiple_extensions(self):
+        fmt = SubtitleFormat(id="ass", extensions=[".ass", ".ssa"])
+        assert fmt.matches_extension(".ass")
+        assert fmt.matches_extension(".ssa")
+        assert fmt.matches_extension(".SSA")
+        assert not fmt.matches_extension(".srt")
+
+
+class TestSubtitleLanguage:
+    def test_matches_token_case_insensitive(self):
+        lang = SubtitleLanguage(code="fra", tokens=["fr", "fre", "french"])
+        assert lang.matches_token("fr")
+        assert lang.matches_token("FRENCH")
+        assert lang.matches_token("French")
+        assert not lang.matches_token("eng")
+
+
+# --------------------------------------------------------------------------- #
+# SubtitleCandidate                                                                #
+# --------------------------------------------------------------------------- #
+
+
+SRT = SubtitleFormat(id="srt", extensions=[".srt"])
+FRA = SubtitleLanguage(code="fra", tokens=["fr", "fre"])
+
+
+class TestSubtitleCandidateDestName:
+    def test_standard(self):
+        t = SubtitleCandidate(
+            language=FRA, format=SRT, subtitle_type=SubtitleType.STANDARD
+        )
+        assert t.destination_name == "fra.srt"
+
+    def test_sdh(self):
+        t = SubtitleCandidate(language=FRA, format=SRT, subtitle_type=SubtitleType.SDH)
+        assert t.destination_name == "fra.sdh.srt"
+
+    def test_forced(self):
+        t = SubtitleCandidate(language=FRA, format=SRT, subtitle_type=SubtitleType.FORCED)
+        assert t.destination_name == "fra.forced.srt"
+
+    def test_unknown_treated_as_standard(self):
+        t = SubtitleCandidate(language=FRA, format=SRT, subtitle_type=SubtitleType.UNKNOWN)
+        # UNKNOWN doesn't add a suffix → same as standard.
+        assert t.destination_name == "fra.srt"
+
+    def test_missing_language_raises(self):
+        t = SubtitleCandidate(language=None, format=SRT)
+        with pytest.raises(ValueError, match="language or format missing"):
+            t.destination_name
+
+    def test_missing_format_raises(self):
+        t = SubtitleCandidate(language=FRA, format=None)
+        with pytest.raises(ValueError, match="language or format missing"):
+            t.destination_name
+
+    def test_extension_dot_stripped(self):
+        # Format extension is ".srt" — leading dot must not be duplicated.
+        t = SubtitleCandidate(language=FRA, format=SRT)
+        assert t.destination_name.endswith(".srt")
+        assert ".." not in t.destination_name
+
+
+class TestSubtitleCandidateRepr:
+    def test_embedded_repr(self):
+        t = SubtitleCandidate(language=FRA, format=None, is_embedded=True, confidence=1.0)
+        r = repr(t)
+        assert "fra" in r
+        assert "embedded" in r
+
+    def test_external_repr_uses_filename(self, tmp_path):
+        f = tmp_path / "fr.srt"
+        f.write_text("")
+        t = SubtitleCandidate(
+            language=FRA, format=SRT, file_path=f, confidence=0.85
+        )
+        r = repr(t)
+        assert "fra" in r
+        assert "fr.srt" in r
+        assert "0.85" in r
+
+    def test_unresolved_repr(self):
+        t = SubtitleCandidate(language=None, format=None)
+        r = repr(t)
+        assert "?" in r
+
+
+# --------------------------------------------------------------------------- #
+# MediaSubtitleMetadata                                                        #
+# --------------------------------------------------------------------------- #
+
+
+class TestMediaSubtitleMetadata:
+    def test_empty(self):
+        m = MediaSubtitleMetadata(media_id=None, media_type="movie")
+        assert m.all_tracks == []
+        assert m.total_count == 0
+        assert m.unresolved_tracks == []
+
+    def test_aggregates_embedded_and_external(self):
+        e = SubtitleCandidate(language=FRA, format=None, is_embedded=True)
+        x = SubtitleCandidate(language=FRA, format=SRT, file_path=Path("/x.srt"))
+        m = MediaSubtitleMetadata(
+            media_id=None,
+            media_type="movie",
+            embedded_tracks=[e],
+            external_tracks=[x],
+        )
+        assert m.total_count == 2
+        assert m.all_tracks == [e, x]
+
+    def test_unresolved_tracks_only_external_with_none_lang(self):
+        # An embedded with None language must NOT appear in unresolved_tracks
+        # (the property only iterates external_tracks).
+        embedded_unknown = SubtitleCandidate(language=None, format=None, is_embedded=True)
+        external_known = SubtitleCandidate(
+            language=FRA, format=SRT, file_path=Path("/a.srt")
+        )
+        external_unknown = SubtitleCandidate(
+            language=None, format=SRT, file_path=Path("/b.srt")
+        )
+        m = MediaSubtitleMetadata(
+            media_id=None,
+            media_type="movie",
+            embedded_tracks=[embedded_unknown],
+            external_tracks=[external_known, external_unknown],
+        )
+        assert m.unresolved_tracks == [external_unknown]
+
+
+# --------------------------------------------------------------------------- #
+# available_subtitles utility                                                  #
+# --------------------------------------------------------------------------- #
+
+
+class TestAvailableSubtitles:
+    def test_dedup_by_lang_and_type(self):
+        ENG = SubtitleLanguage(code="eng", tokens=["en"])
+        tracks = [
+            SubtitleCandidate(language=FRA, format=SRT, subtitle_type=SubtitleType.STANDARD),
+            SubtitleCandidate(language=FRA, format=SRT, subtitle_type=SubtitleType.STANDARD),
+            SubtitleCandidate(language=FRA, format=SRT, subtitle_type=SubtitleType.SDH),
+            SubtitleCandidate(language=ENG, format=SRT, subtitle_type=SubtitleType.STANDARD),
+        ]
+        result = available_subtitles(tracks)
+        keys = [(t.language.code, t.subtitle_type) for t in result]
+        assert keys == [
+            ("fra", SubtitleType.STANDARD),
+            ("fra", SubtitleType.SDH),
+            ("eng", SubtitleType.STANDARD),
+        ]
+
+    def test_none_language_treated_as_key(self):
+        # Tracks with no language form a single None-keyed bucket.
+        t1 = SubtitleCandidate(
+            language=None, format=SRT, subtitle_type=SubtitleType.UNKNOWN
+        )
+        t2 = SubtitleCandidate(
+            language=None, format=SRT, subtitle_type=SubtitleType.UNKNOWN
+        )
+        result = available_subtitles([t1, t2])
+        assert len(result) == 1
+
+    def test_empty(self):
+        assert available_subtitles([]) == []
+
+
+# --------------------------------------------------------------------------- #
+# SubtitleRuleSet inheritance                                                  #
+# --------------------------------------------------------------------------- #
+
+
+class TestSubtitleRuleSet:
+    def test_global_default_uses_kb_defaults(self):
+        rs = SubtitleRuleSet.global_default()
+        rules = rs.resolve()
+        # Loaded from subtitles.yaml — defaults must be non-empty.
+        assert rules.preferred_languages
+        assert rules.preferred_formats
+        assert 0 < rules.min_confidence <= 1
+
+    def test_override_persists(self):
+        rs = SubtitleRuleSet.global_default()
+        rs.override(languages=["eng"], min_confidence=0.9)
+        rules = rs.resolve()
+        assert rules.preferred_languages == ["eng"]
+        assert rules.min_confidence == 0.9
+
+    def test_override_partial_keeps_parent_for_unset_fields(self):
+        parent = SubtitleRuleSet.global_default()
+        child = SubtitleRuleSet(
+            scope=RuleScope(level="show", identifier="tt1"),
+            parent=parent,
+        )
+        child.override(languages=["jpn"])
+        rules = child.resolve()
+        assert rules.preferred_languages == ["jpn"]
+        # min_confidence not overridden at child or parent → falls back to defaults
+        assert rules.min_confidence == parent.resolve().min_confidence
+
+    def test_to_dict_only_emits_set_deltas(self):
+        rs = SubtitleRuleSet(scope=RuleScope(level="show", identifier="tt1"))
+        rs.override(languages=["fra"])
+        out = rs.to_dict()
+        assert out["scope"] == {"level": "show", "identifier": "tt1"}
+        assert out["override"] == {"languages": ["fra"]}
+
+    def test_to_dict_full_override(self):
+        rs = SubtitleRuleSet(scope=RuleScope(level="global"))
+        rs.override(
+            languages=["fra"],
+            formats=["srt"],
+            types=["standard"],
+            format_priority=["srt", "ass"],
+            min_confidence=0.8,
+        )
+        out = rs.to_dict()
+        ov = out["override"]
+        assert ov["languages"] == ["fra"]
+        assert ov["formats"] == ["srt"]
+        assert ov["types"] == ["standard"]
+        assert ov["format_priority"] == ["srt", "ass"]
+        assert ov["min_confidence"] == 0.8
+
+    def test_min_confidence_zero_is_respected(self):
+        # `_min_confidence or base.min_confidence` would be a bug here — the
+        # code uses `is not None` explicitly. Verify 0.0 doesn't fall back.
+        rs = SubtitleRuleSet.global_default()
+        rs.override(min_confidence=0.0)
+        assert rs.resolve().min_confidence == 0.0