ha-nvidia-shield/tests/test_media_sources.py

"""tests/test_media_sources.py — source_list, source and native select_source (t47).

The last piece a universal-media-player replacement needs from this integration:
a dropdown of the apps (``source_list``), an answer to "what is on screen"
(``source``), and a way to pick one (``media_player.select_source``). All three read
the SAME app directory — the user's Apps map, else the curated default — so the
dropdown cannot offer a name the launch path cannot resolve.

The t44 rule still holds: a configured ``select_source`` script takes precedence,
because selecting a source can be more than launching an app. Without one, the name
resolves back to its package and goes out over the shared ``play_media("app", …)``
path; an unknown name is a translated error, never a silent no-op.
"""

import entity_stublib
import pytest
from nsh.const import CONF_APP_NAME_MAP, CONF_COMMAND_SCRIPTS, SCRIPT_VAR_APP_NAME
from test_command_routing import make_player

TIVIMATE = "ar.tvplayer.tv"
SCRIPT = "script.shield_source"


@pytest.fixture(name="modules", autouse=True)
def scoped_modules():
    """Stub scope + loaded entity modules for one test (t7 discipline)."""
    snapshot = entity_stublib.snapshot_modules()
    entity_stublib.install()
    try:
        yield entity_stublib.load_entity_modules()
    finally:
        entity_stublib.restore_modules(snapshot)


def _player(modules, *, app_map=None, scripts=None, foreground=None):
    player, served, _intents = make_player(modules)
    if app_map is not None:
        player._entry.options[CONF_APP_NAME_MAP] = app_map
    if scripts is not None:
        player._entry.options[CONF_COMMAND_SCRIPTS] = scripts
    if foreground is not None:
        player._manager._on_current_app(foreground)
    return player, served


class TestSourceList:
    """The dropdown: friendly names, in a stable order, from the one directory."""

    def test_it_comes_from_the_apps_map(self, modules):
        player, _served = _player(
            modules,
            app_map={"com.custom.one": "One", "com.custom.two": "Two"},
        )

        assert player.source_list == ["One", "Two"]  # map order, not shuffled

    def test_it_falls_back_to_the_curated_directory(self, modules):
        player, _served = _player(modules)  # no map configured

        assert player.source_list == ["TiviMate", "Wholphin", "Netflix", "YouTube"]

    def test_every_offered_name_resolves_to_a_package(self, modules):
        """The invariant the shared directory buys: no name without a destination."""
        for app_map in (None, {"com.custom.one": "One"}):
            player, _served = _player(modules, app_map=app_map)

            for name in player.source_list:
                assert player._source_package(name) is not None, name


class TestSource:
    """`source` is the foreground app's resolved name — the app_name chain."""

    def test_it_resolves_through_the_apps_map(self, modules):
        player, _served = _player(
            modules, app_map={TIVIMATE: "TiviMate"}, foreground=TIVIMATE
        )

        assert player.source == "TiviMate"
        assert player.source == player.app_name  # one truth, not two

    def test_it_uses_the_cached_device_label_when_unmapped(self, modules):
        player, _served = _player(modules, foreground="com.netflix.ninja")
        player._manager._app_labels["com.netflix.ninja"] = (
            "Netflix",
            player._manager._clock(),
        )

        assert player.source == "Netflix"

    def test_it_falls_back_to_the_raw_package(self, modules):
        player, _served = _player(modules, foreground="com.unknown.app")

        assert player.source == "com.unknown.app"

    def test_it_is_unknown_when_nothing_has_reported(self, modules):
        player, _served = _player(modules)

        assert player.source is None


class TestSelectSource:
    """Picking a source: script first, else the native launch, else an error."""

    async def test_a_name_launches_its_package(self, modules):
        player, served = _player(
            modules, app_map={TIVIMATE: "TiviMate", "com.netflix.ninja": "Netflix"}
        )

        await player.async_select_source("TiviMate")

        assert player._manager._protocol.launch_calls == [TIVIMATE]
        assert served == []  # no script was configured, and nothing else left

    async def test_the_curated_names_launch_too(self, modules):
        player, _served = _player(modules)

        await player.async_select_source("Netflix")

        assert player._manager._protocol.launch_calls == ["com.netflix.ninja"]

    async def test_a_raw_package_and_any_case_are_accepted(self, modules):
        player, _served = _player(
            modules, app_map={TIVIMATE: "TiviMate", "com.netflix.ninja": "Netflix"}
        )

        await player.async_select_source(TIVIMATE)
        await player.async_select_source("tivimate")
        await player.async_select_source("  NETFLIX  ")

        assert player._manager._protocol.launch_calls == [
            TIVIMATE,
            TIVIMATE,
            "com.netflix.ninja",
        ]

    async def test_a_configured_script_still_wins(self, modules):
        player, served = _player(
            modules,
            app_map={TIVIMATE: "TiviMate"},
            scripts={"select_source": SCRIPT},
        )

        await player.async_select_source("TiviMate")

        assert served == [
            (
                "script",
                "turn_on",
                {"entity_id": SCRIPT, "variables": {SCRIPT_VAR_APP_NAME: "TiviMate"}},
            )
        ]
        assert player._manager._protocol.launch_calls == []  # native path untouched

    async def test_an_unknown_name_raises_a_translated_error(self, modules):
        from homeassistant.exceptions import ServiceValidationError

        player, _served = _player(modules, app_map={TIVIMATE: "TiviMate"})

        with pytest.raises(ServiceValidationError) as raised:
            await player.async_select_source("Not An App")

        assert raised.value.translation_domain == "nvidia_shield"
        assert raised.value.translation_key == "unknown_source"
        assert raised.value.translation_placeholders == {"source": "Not An App"}
        assert player._manager._protocol.launch_calls == []  # nothing was sent

    async def test_an_empty_name_is_an_error_too(self, modules):
        from homeassistant.exceptions import ServiceValidationError

        player, _served = _player(modules)

        with pytest.raises(ServiceValidationError):
            await player.async_select_source("   ")


class TestAdvertisedFeatures:
    """HA routes a service by its feature flag, so the flag has to be honest."""

    def test_a_source_list_advertises_select_source(self, modules):
        from homeassistant.components.media_player import MediaPlayerEntityFeature

        player, _served = _player(modules)

        assert player.supported_features & MediaPlayerEntityFeature.SELECT_SOURCE

    def test_a_script_advertises_it_even_with_no_directory(self, modules, monkeypatch):
        from homeassistant.components.media_player import MediaPlayerEntityFeature

        player, _served = _player(modules, scripts={"select_source": SCRIPT})
        monkeypatch.setattr(type(player), "_app_directory", property(lambda self: {}))

        assert player.supported_features & MediaPlayerEntityFeature.SELECT_SOURCE

    def test_neither_means_it_is_not_offered(self, modules, monkeypatch):
        from homeassistant.components.media_player import MediaPlayerEntityFeature

        player, _served = _player(modules)
        monkeypatch.setattr(type(player), "_app_directory", property(lambda self: {}))

        assert not player.supported_features & MediaPlayerEntityFeature.SELECT_SOURCE

    def test_select_source_is_not_gated_on_the_volume_set_script(self, modules):
        """The two script-only commands stay independent."""
        from homeassistant.components.media_player import MediaPlayerEntityFeature

        player, _served = _player(modules, scripts={"volume_set": "script.volume"})

        assert player.supported_features & MediaPlayerEntityFeature.VOLUME_SET
        assert player.supported_features & MediaPlayerEntityFeature.SELECT_SOURCE