alfred/tests/application/test_enrich_from_probe.py

"""Tests for ``alfred.application.filesystem.enrich_from_probe``.

The function mutates a ``ParsedRelease`` in place using ffprobe ``MediaInfo``.
Token-level values from the release name always win — only ``None`` fields
are filled.

Coverage:

- ``TestQuality`` — resolution fill-in (and no-overwrite).
- ``TestVideoCodec`` — codec map (hevc→x265, …) + uppercase fallback.
- ``TestAudio`` — default track preferred over first; codec & channel maps
  with unknown-value fallbacks.
- ``TestLanguages`` — append-only merge; ``und`` skipped; case-insensitive
  duplicate suppression.

Uses real ``ParsedRelease`` / ``MediaInfo`` instances — no mocking needed.
"""

from __future__ import annotations

from alfred.application.filesystem.enrich_from_probe import enrich_from_probe
from alfred.domain.release.value_objects import ParsedRelease
from alfred.domain.shared.media import AudioTrack, MediaInfo, VideoTrack


def _info_with_video(*, width=None, height=None, codec=None, **rest) -> MediaInfo:
    """Helper: build a MediaInfo with a single video track (the common case)."""
    return MediaInfo(
        video_tracks=[VideoTrack(index=0, codec=codec, width=width, height=height)],
        **rest,
    )


def _bare(**overrides) -> ParsedRelease:
    """Build a minimal ParsedRelease with all enrichable fields = None."""
    defaults = dict(
        raw="X",
        normalised="X",
        title="X",
        year=None,
        season=None,
        episode=None,
        episode_end=None,
        quality=None,
        source=None,
        codec=None,
        group="UNKNOWN",
        tech_string="",
    )
    defaults.update(overrides)
    return ParsedRelease(**defaults)


# --------------------------------------------------------------------------- #
# Quality / resolution                                                         #
# --------------------------------------------------------------------------- #


class TestQuality:
    def test_fills_when_none(self):
        p = _bare()
        enrich_from_probe(p, _info_with_video(width=1920, height=1080))
        assert p.quality == "1080p"

    def test_does_not_overwrite_existing(self):
        p = _bare(quality="2160p")
        enrich_from_probe(p, _info_with_video(width=1920, height=1080))
        assert p.quality == "2160p"

    def test_no_dims_leaves_none(self):
        p = _bare()
        enrich_from_probe(p, MediaInfo())
        assert p.quality is None


# --------------------------------------------------------------------------- #
# Video codec                                                                  #
# --------------------------------------------------------------------------- #


class TestVideoCodec:
    def test_hevc_to_x265(self):
        p = _bare()
        enrich_from_probe(p, _info_with_video(codec="hevc"))
        assert p.codec == "x265"

    def test_h264_to_x264(self):
        p = _bare()
        enrich_from_probe(p, _info_with_video(codec="h264"))
        assert p.codec == "x264"

    def test_unknown_codec_uppercased(self):
        p = _bare()
        enrich_from_probe(p, _info_with_video(codec="weird"))
        assert p.codec == "WEIRD"

    def test_does_not_overwrite_existing(self):
        p = _bare(codec="HEVC")
        enrich_from_probe(p, _info_with_video(codec="h264"))
        assert p.codec == "HEVC"

    def test_no_codec_leaves_none(self):
        p = _bare()
        enrich_from_probe(p, MediaInfo())
        assert p.codec is None


# --------------------------------------------------------------------------- #
# Audio                                                                        #
# --------------------------------------------------------------------------- #


class TestAudio:
    def test_uses_default_track(self):
        info = MediaInfo(
            audio_tracks=[
                AudioTrack(0, "aac", 2, "stereo", "eng", is_default=False),
                AudioTrack(1, "eac3", 6, "5.1", "eng", is_default=True),
            ]
        )
        p = _bare()
        enrich_from_probe(p, info)
        assert p.audio_codec == "EAC3"
        assert p.audio_channels == "5.1"

    def test_falls_back_to_first_track_when_no_default(self):
        info = MediaInfo(
            audio_tracks=[
                AudioTrack(0, "ac3", 6, "5.1", "eng"),
                AudioTrack(1, "aac", 2, "stereo", "fre"),
            ]
        )
        p = _bare()
        enrich_from_probe(p, info)
        assert p.audio_codec == "AC3"
        assert p.audio_channels == "5.1"

    def test_channel_count_unknown_falls_back(self):
        info = MediaInfo(
            audio_tracks=[AudioTrack(0, "aac", 4, "quad", "eng")]
        )
        p = _bare()
        enrich_from_probe(p, info)
        assert p.audio_channels == "4ch"

    def test_unknown_audio_codec_uppercased(self):
        info = MediaInfo(
            audio_tracks=[AudioTrack(0, "newcodec", 2, "stereo", "eng")]
        )
        p = _bare()
        enrich_from_probe(p, info)
        assert p.audio_codec == "NEWCODEC"

    def test_no_audio_tracks(self):
        p = _bare()
        enrich_from_probe(p, MediaInfo())
        assert p.audio_codec is None
        assert p.audio_channels is None

    def test_does_not_overwrite_existing_audio_fields(self):
        info = MediaInfo(
            audio_tracks=[AudioTrack(0, "ac3", 6, "5.1", "eng")]
        )
        p = _bare(audio_codec="DTS-HD.MA", audio_channels="7.1")
        enrich_from_probe(p, info)
        assert p.audio_codec == "DTS-HD.MA"
        assert p.audio_channels == "7.1"


# --------------------------------------------------------------------------- #
# Languages                                                                    #
# --------------------------------------------------------------------------- #


class TestLanguages:
    def test_appends_new(self):
        info = MediaInfo(
            audio_tracks=[
                AudioTrack(0, "aac", 2, "stereo", "eng"),
                AudioTrack(1, "aac", 2, "stereo", "fre"),
            ]
        )
        p = _bare()
        enrich_from_probe(p, info)
        assert p.languages == ["eng", "fre"]

    def test_skips_und(self):
        info = MediaInfo(
            audio_tracks=[
                AudioTrack(0, "aac", 2, "stereo", "und"),
                AudioTrack(1, "aac", 2, "stereo", "eng"),
            ]
        )
        p = _bare()
        enrich_from_probe(p, info)
        assert p.languages == ["eng"]

    def test_dedup_against_existing_case_insensitive(self):
        # existing token-level languages are typically upper-case ("FRENCH", "ENG")
        # The current logic compares track.lang.upper() against existing —
        # so a track with "eng" is suppressed if "ENG" is already in languages.
        info = MediaInfo(
            audio_tracks=[
                AudioTrack(0, "aac", 2, "stereo", "eng"),
                AudioTrack(1, "aac", 2, "stereo", "fre"),
            ]
        )
        p = _bare()
        p.languages = ["ENG"]
        enrich_from_probe(p, info)
        # "eng" → upper "ENG" already present → skipped. "fre" → "FRE" new → kept.
        assert p.languages == ["ENG", "fre"]

    def test_no_audio_tracks_leaves_languages_empty(self):
        p = _bare()
        enrich_from_probe(p, MediaInfo())
        assert p.languages == []