236 lines
8.1 KiB
Python
236 lines
8.1 KiB
Python
from __future__ import annotations
|
|
|
|
import html
|
|
import json
|
|
import re
|
|
|
|
import pytest
|
|
|
|
from beefy_player import config
|
|
from beefy_player.models import Song, Station
|
|
from beefy_player.providers import PROVIDERS, available_providers, get_provider
|
|
from beefy_player.providers.base import RadioProvider
|
|
from beefy_player.providers.somafm import SomaFMProvider
|
|
from beefy_player.providers.tilderadio import TilderadioProvider
|
|
from beefy_player.widgets.header import HeaderBar
|
|
|
|
|
|
def rendered_text(app) -> str:
|
|
svg = html.unescape(app.export_screenshot()).replace("\xa0", " ")
|
|
return re.sub(r"<[^>]+>", " ", svg)
|
|
|
|
|
|
def test_registry_lists_somafm_as_the_default() -> None:
|
|
assert available_providers() == ("somafm", "tilderadio")
|
|
assert isinstance(get_provider(), SomaFMProvider)
|
|
assert get_provider("somafm") is get_provider()
|
|
assert isinstance(get_provider("tilderadio"), TilderadioProvider)
|
|
# a stale slug in the config file must not stop the app from starting
|
|
assert get_provider("no-such-catalogue") is get_provider()
|
|
|
|
|
|
def test_somafm_provider_describes_its_catalogue() -> None:
|
|
provider = get_provider()
|
|
assert provider.name == "SomaFM"
|
|
assert provider.brand == "SOMA FM"
|
|
assert provider.station_source == "somafm.com/channels.json"
|
|
assert "somafm.com" in provider.user_agent
|
|
|
|
stations = provider.fallback_stations()
|
|
assert len(stations) > 40
|
|
station = stations[0]
|
|
assert station.provider == "somafm"
|
|
assert station.uid == f"somafm:{station.id}"
|
|
assert all("somafm.com" in url for url in provider.fallback_urls(station))
|
|
|
|
|
|
class FakeProvider(RadioProvider):
|
|
"""A second catalogue, as small as the interface allows."""
|
|
|
|
id = "fake"
|
|
name = "Fake FM"
|
|
homepage = "fake.test"
|
|
brand = "FAKE FM"
|
|
tagline = "not real radio"
|
|
station_source = "fake.test/stations.json"
|
|
history_source = "recent.json"
|
|
|
|
def __init__(self) -> None:
|
|
self.station = Station(
|
|
id="one", title="Fake One", genre="test", provider=self.id
|
|
)
|
|
|
|
async def fetch_stations(self, client):
|
|
return [self.station]
|
|
|
|
def load_cached_stations(self):
|
|
return [self.station]
|
|
|
|
def fallback_stations(self):
|
|
return [self.station]
|
|
|
|
async def fetch_history(self, client, station_id):
|
|
return [Song(title="Tune", artist="Someone")]
|
|
|
|
def load_cached_history(self, station_id):
|
|
return []
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_app_runs_against_a_different_catalogue(monkeypatch) -> None:
|
|
"""The UI must not know which catalogue it is showing."""
|
|
from beefy_player.app import BeefyPlayerApp
|
|
|
|
fake = FakeProvider()
|
|
monkeypatch.setitem(PROVIDERS, "fake", fake)
|
|
app = BeefyPlayerApp(provider="fake", autoplay=False, offline=True, audio=False)
|
|
assert app.provider is fake
|
|
async with app.run_test(size=(100, 30)) as pilot:
|
|
await pilot.pause()
|
|
assert app.current is not None
|
|
assert app.current.uid == "fake:one"
|
|
app.query_one("StagePanel").refresh_stage()
|
|
await pilot.pause()
|
|
text = rendered_text(app)
|
|
assert "FAKE ONE" in text
|
|
assert "Fake FM" in app.title
|
|
|
|
|
|
def test_config_remembers_the_provider() -> None:
|
|
assert config.Config.load().provider == "somafm"
|
|
config.Config(provider="fake").save()
|
|
assert config.Config.load().provider == "fake"
|
|
|
|
|
|
def test_legacy_config_is_migrated_once(monkeypatch) -> None:
|
|
legacy = config.LEGACY_CONFIG_PATH
|
|
legacy.parent.mkdir(parents=True, exist_ok=True)
|
|
legacy.write_text(
|
|
json.dumps({"favorites": ["defcon"], "volume": 33, "last_station": "dronezone"})
|
|
)
|
|
|
|
loaded = config.Config.load()
|
|
assert loaded.favorites == ["defcon"]
|
|
assert loaded.volume == 33
|
|
assert loaded.last_station == "dronezone"
|
|
assert config.CONFIG_PATH.exists()
|
|
|
|
# the new file wins from then on
|
|
config.Config(volume=11).save()
|
|
legacy.write_text(json.dumps({"volume": 99}))
|
|
assert config.Config.load().volume == 11
|
|
|
|
|
|
def test_environment_variables_prefer_the_beefy_prefix(monkeypatch) -> None:
|
|
monkeypatch.setenv("BEEFY_IMAGES", "tgp")
|
|
monkeypatch.setenv("SOMAFM_IMAGES", "0")
|
|
assert config.env_var("IMAGES") == "tgp"
|
|
|
|
monkeypatch.delenv("BEEFY_IMAGES")
|
|
assert config.env_var("IMAGES") == "0" # the old spelling still works
|
|
|
|
monkeypatch.delenv("SOMAFM_IMAGES")
|
|
assert config.env_var("IMAGES") == ""
|
|
|
|
|
|
def test_tilderadio_replaces_the_station_list_with_a_schedule() -> None:
|
|
provider = TilderadioProvider()
|
|
assert provider.has_schedule is True
|
|
# the SomaFM wordmark's slot now holds tilderadio's own art and motto
|
|
assert provider.hero and not provider.hero_gradient
|
|
assert provider.hero_lines == (
|
|
"TILDERADIO",
|
|
"STREAMED BY / FOR USERS OF THE",
|
|
"TILDEVERSE",
|
|
)
|
|
assert SomaFMProvider().has_schedule is False
|
|
|
|
|
|
class _CatalogueApp:
|
|
"""A headless app on a fixed catalogue, for the picker tests."""
|
|
|
|
def __init__(self, provider: str = "somafm") -> None:
|
|
from beefy_player.app import BeefyPlayerApp
|
|
|
|
self.app = BeefyPlayerApp(
|
|
provider=provider, autoplay=False, offline=True, audio=False
|
|
)
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_p_opens_the_picker_and_switches_catalogue() -> None:
|
|
from beefy_player.widgets.providers import ProviderScreen
|
|
from beefy_player.widgets.schedule import SchedulePanel
|
|
from beefy_player.widgets.station_list import StationList
|
|
|
|
app = _CatalogueApp().app
|
|
async with app.run_test(size=(110, 40)) as pilot:
|
|
await pilot.pause()
|
|
assert app.provider.id == "somafm"
|
|
assert app.query_one(StationList).display is True
|
|
assert app.query_one(SchedulePanel).display is False
|
|
assert app.query_one(HeaderBar).styles.height.value == 4
|
|
|
|
await pilot.press("p")
|
|
await pilot.pause()
|
|
assert isinstance(app.screen, ProviderScreen)
|
|
|
|
await pilot.press("2") # jump straight to tilderadio
|
|
await pilot.pause()
|
|
await pilot.pause()
|
|
|
|
assert app.provider.id == "tilderadio"
|
|
assert app.config.provider == "tilderadio"
|
|
assert [station.id for station in app.stations] == ["tilderadio"]
|
|
# the left pane becomes the schedule, and the hero grows
|
|
assert app.query_one(StationList).display is False
|
|
assert app.query_one(SchedulePanel).display is True
|
|
assert app.query_one(HeaderBar).styles.height.value == 8
|
|
assert "tilderadio" in app.title
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_escape_closes_the_picker_without_switching() -> None:
|
|
app = _CatalogueApp().app
|
|
async with app.run_test(size=(110, 40)) as pilot:
|
|
await pilot.pause()
|
|
await pilot.press("p")
|
|
await pilot.pause()
|
|
await pilot.press("escape")
|
|
await pilot.pause()
|
|
assert app.provider.id == "somafm"
|
|
assert app.config.provider != "tilderadio"
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_help_names_both_catalogues_and_the_switch_key() -> None:
|
|
app = _CatalogueApp().app
|
|
async with app.run_test(size=(120, 60)) as pilot:
|
|
await pilot.pause()
|
|
await pilot.press("question_mark")
|
|
await pilot.pause()
|
|
text = rendered_text(app)
|
|
assert "CATALOGUES" in text
|
|
assert "somafm" in text and "tilderadio" in text
|
|
assert "switch station catalogue" in text
|
|
|
|
|
|
def test_config_remembers_a_station_per_catalogue() -> None:
|
|
config.Config(last_stations={"somafm": "defcon", "tilderadio": "tilderadio"}).save()
|
|
loaded = config.Config.load()
|
|
assert loaded.last_station_for("somafm") == "defcon"
|
|
assert loaded.last_station_for("tilderadio") == "tilderadio"
|
|
# a catalogue nobody has tuned yet falls back to the legacy single field
|
|
assert loaded.last_station_for("no-such-catalogue") == loaded.last_station
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_short_terminals_crop_the_hero_but_keep_the_ticker() -> None:
|
|
app = _CatalogueApp("tilderadio").app
|
|
async with app.run_test(size=(90, 24)) as pilot:
|
|
await pilot.pause()
|
|
header = app.query_one(HeaderBar)
|
|
assert header.styles.height.value <= 6
|
|
lines = [line.plain for line in header.render().renderables]
|
|
assert any("STOPPED" in line or "PLAYING" in line for line in lines)
|