Add forked_daapd integration (#31953)
* New forked_daapd component * Bunch of changes Add config flow and zeroconf Add zones on callback when added by server Add password auth Add async_play_media for TTS Add media_image_url Add support for pipe control/input from librespot-java Improve update callbacks * Refactor as per code review suggestions Move config_flow connection testing to pypi library (v0.1.4) Remove use of ForkedDaapdData class Decouple Master and Zone data and functions Add updater class to manage websocket and entity updates * More changes as per code review Avoid direct access to entities in tests Bump pypi version Mark entities unavailable when websocket disconnected Move config tests to test_config_flow Move full url creation from media_image_url to library Move updater entity from master to hass.data Remove default unmute volume option Remove name from config_flow Remove storage of entities in hass.data Use async_write_ha_state Use signal to trigger update_options Use unittest.mock instead of asynctest.mock * Yet more changes as per code review Add more assertions in tests Avoid patching asyncio Make off state require player state stopped Only send update to existing zones Split up some tests Use events instead of async_block_till_done Use sets instead of lists where applicable Wait for pause callback before continuing TTS * Remove unnecessary use of Future() * Add pipes and playlists as sources * Add support for multiple servers Change config options to add max_playlists+remove use_pipe_control Create Machine ID in test_connection and also get from zeroconf Modify hass.data storage Update host for known configurations Use Machine ID in unique_ids, entity names, config title, signals * Use entry_id as basis for multiple entries * Use f-strings and str.format, abort for same host * Clean up check for same host
This commit is contained in:
1 parent
c12f8bed43
commit
c41fb2a21f
15 files changed
+2179
No files matched your search
@@ -0,0 +1 @@
|
||||
"""Tests for the forked_daapd component."""
|
||||
@@ -0,0 +1,181 @@
|
||||
"""The config flow tests for the forked_daapd media player platform."""
|
||||
import pytest
|
||||
|
||||
from homeassistant import data_entry_flow
|
||||
from homeassistant.components.forked_daapd.const import (
|
||||
CONF_LIBRESPOT_JAVA_PORT,
|
||||
CONF_MAX_PLAYLISTS,
|
||||
CONF_TTS_PAUSE_TIME,
|
||||
CONF_TTS_VOLUME,
|
||||
DOMAIN,
|
||||
)
|
||||
from homeassistant.config_entries import (
|
||||
CONN_CLASS_LOCAL_PUSH,
|
||||
SOURCE_USER,
|
||||
SOURCE_ZEROCONF,
|
||||
)
|
||||
from homeassistant.const import CONF_HOST, CONF_PASSWORD, CONF_PORT
|
||||
|
||||
from tests.async_mock import patch
|
||||
from tests.common import MockConfigEntry
|
||||
|
||||
SAMPLE_CONFIG = {
|
||||
"websocket_port": 3688,
|
||||
"version": "25.0",
|
||||
"buildoptions": [
|
||||
"ffmpeg",
|
||||
"iTunes XML",
|
||||
"Spotify",
|
||||
"LastFM",
|
||||
"MPD",
|
||||
"Device verification",
|
||||
"Websockets",
|
||||
"ALSA",
|
||||
],
|
||||
}
|
||||
|
||||
|
||||
@pytest.fixture(name="config_entry")
|
||||
def config_entry_fixture():
|
||||
"""Create hass config_entry fixture."""
|
||||
data = {
|
||||
CONF_HOST: "192.168.1.1",
|
||||
CONF_PORT: "2345",
|
||||
CONF_PASSWORD: "",
|
||||
}
|
||||
return MockConfigEntry(
|
||||
version=1,
|
||||
domain=DOMAIN,
|
||||
title="",
|
||||
data=data,
|
||||
options={},
|
||||
system_options={},
|
||||
source=SOURCE_USER,
|
||||
connection_class=CONN_CLASS_LOCAL_PUSH,
|
||||
entry_id=1,
|
||||
)
|
||||
|
||||
|
||||
async def test_show_form(hass):
|
||||
"""Test that the form is served with no input."""
|
||||
result = await hass.config_entries.flow.async_init(
|
||||
DOMAIN, context={"source": SOURCE_USER}
|
||||
)
|
||||
|
||||
assert result["type"] == data_entry_flow.RESULT_TYPE_FORM
|
||||
assert result["step_id"] == SOURCE_USER
|
||||
|
||||
|
||||
async def test_config_flow(hass, config_entry):
|
||||
"""Test that the user step works."""
|
||||
with patch(
|
||||
"homeassistant.components.forked_daapd.config_flow.ForkedDaapdAPI.test_connection"
|
||||
) as mock_test_connection, patch(
|
||||
"homeassistant.components.forked_daapd.media_player.ForkedDaapdAPI.get_request",
|
||||
autospec=True,
|
||||
) as mock_get_request:
|
||||
mock_get_request.return_value = SAMPLE_CONFIG
|
||||
mock_test_connection.return_value = ["ok", "My Music on myhost"]
|
||||
config_data = config_entry.data
|
||||
result = await hass.config_entries.flow.async_init(
|
||||
DOMAIN, context={"source": SOURCE_USER}, data=config_data
|
||||
)
|
||||
await hass.async_block_till_done()
|
||||
assert result["type"] == data_entry_flow.RESULT_TYPE_CREATE_ENTRY
|
||||
assert result["title"] == "My Music on myhost"
|
||||
assert result["data"][CONF_HOST] == config_data[CONF_HOST]
|
||||
assert result["data"][CONF_PORT] == config_data[CONF_PORT]
|
||||
assert result["data"][CONF_PASSWORD] == config_data[CONF_PASSWORD]
|
||||
|
||||
# Also test that creating a new entry with the same host aborts
|
||||
result = await hass.config_entries.flow.async_init(
|
||||
DOMAIN, context={"source": SOURCE_USER}, data=config_entry.data,
|
||||
)
|
||||
await hass.async_block_till_done()
|
||||
assert result["type"] == data_entry_flow.RESULT_TYPE_ABORT
|
||||
|
||||
|
||||
async def test_zeroconf_updates_title(hass, config_entry):
|
||||
"""Test that zeroconf updates title and aborts with same host."""
|
||||
MockConfigEntry(domain=DOMAIN, data={CONF_HOST: "different host"}).add_to_hass(hass)
|
||||
config_entry.add_to_hass(hass)
|
||||
assert len(hass.config_entries.async_entries(DOMAIN)) == 2
|
||||
discovery_info = {
|
||||
"host": "192.168.1.1",
|
||||
"port": 23,
|
||||
"properties": {"mtd-version": 1, "Machine Name": "zeroconf_test"},
|
||||
}
|
||||
result = await hass.config_entries.flow.async_init(
|
||||
DOMAIN, context={"source": SOURCE_ZEROCONF}, data=discovery_info
|
||||
)
|
||||
await hass.async_block_till_done()
|
||||
assert result["type"] == data_entry_flow.RESULT_TYPE_ABORT
|
||||
assert config_entry.title == "zeroconf_test"
|
||||
assert len(hass.config_entries.async_entries(DOMAIN)) == 2
|
||||
|
||||
|
||||
async def test_config_flow_no_websocket(hass, config_entry):
|
||||
"""Test config flow setup without websocket enabled on server."""
|
||||
with patch(
|
||||
"homeassistant.components.forked_daapd.config_flow.ForkedDaapdAPI.test_connection"
|
||||
) as mock_test_connection:
|
||||
# test invalid config data
|
||||
mock_test_connection.return_value = ["websocket_not_enabled"]
|
||||
result = await hass.config_entries.flow.async_init(
|
||||
DOMAIN, context={"source": SOURCE_USER}, data=config_entry.data
|
||||
)
|
||||
assert result["type"] == data_entry_flow.RESULT_TYPE_FORM
|
||||
|
||||
|
||||
async def test_config_flow_zeroconf_invalid(hass):
|
||||
"""Test that an invalid zeroconf entry doesn't work."""
|
||||
discovery_info = {"host": "127.0.0.1", "port": 23}
|
||||
result = await hass.config_entries.flow.async_init(
|
||||
DOMAIN, context={"source": SOURCE_ZEROCONF}, data=discovery_info
|
||||
) # doesn't create the entry, tries to show form but gets abort
|
||||
assert result["type"] == data_entry_flow.RESULT_TYPE_ABORT
|
||||
assert result["reason"] == "not_forked_daapd"
|
||||
|
||||
|
||||
async def test_config_flow_zeroconf_valid(hass):
|
||||
"""Test that a valid zeroconf entry works."""
|
||||
discovery_info = {
|
||||
"host": "192.168.1.1",
|
||||
"port": 23,
|
||||
"properties": {
|
||||
"mtd-version": 1,
|
||||
"Machine Name": "zeroconf_test",
|
||||
"Machine ID": "5E55EEFF",
|
||||
},
|
||||
}
|
||||
result = await hass.config_entries.flow.async_init(
|
||||
DOMAIN, context={"source": SOURCE_ZEROCONF}, data=discovery_info
|
||||
)
|
||||
assert result["type"] == data_entry_flow.RESULT_TYPE_FORM
|
||||
|
||||
|
||||
async def test_options_flow(hass, config_entry):
|
||||
"""Test config flow options."""
|
||||
|
||||
with patch(
|
||||
"homeassistant.components.forked_daapd.media_player.ForkedDaapdAPI.get_request",
|
||||
autospec=True,
|
||||
) as mock_get_request:
|
||||
mock_get_request.return_value = SAMPLE_CONFIG
|
||||
config_entry.add_to_hass(hass)
|
||||
await config_entry.async_setup(hass)
|
||||
await hass.async_block_till_done()
|
||||
|
||||
result = await hass.config_entries.options.async_init(config_entry.entry_id)
|
||||
assert result["type"] == data_entry_flow.RESULT_TYPE_FORM
|
||||
|
||||
result = await hass.config_entries.options.async_configure(
|
||||
result["flow_id"],
|
||||
user_input={
|
||||
CONF_TTS_PAUSE_TIME: 0.05,
|
||||
CONF_TTS_VOLUME: 0.8,
|
||||
CONF_LIBRESPOT_JAVA_PORT: 0,
|
||||
CONF_MAX_PLAYLISTS: 8,
|
||||
},
|
||||
)
|
||||
assert result["type"] == data_entry_flow.RESULT_TYPE_CREATE_ENTRY
|
||||
@@ -0,0 +1,726 @@
|
||||
"""The media player tests for the forked_daapd media player platform."""
|
||||
|
||||
import pytest
|
||||
|
||||
from homeassistant.components.forked_daapd.const import (
|
||||
CONF_LIBRESPOT_JAVA_PORT,
|
||||
CONF_MAX_PLAYLISTS,
|
||||
CONF_TTS_PAUSE_TIME,
|
||||
CONF_TTS_VOLUME,
|
||||
DOMAIN,
|
||||
SOURCE_NAME_CLEAR,
|
||||
SOURCE_NAME_DEFAULT,
|
||||
SUPPORTED_FEATURES,
|
||||
SUPPORTED_FEATURES_ZONE,
|
||||
)
|
||||
from homeassistant.components.media_player import (
|
||||
SERVICE_CLEAR_PLAYLIST,
|
||||
SERVICE_MEDIA_NEXT_TRACK,
|
||||
SERVICE_MEDIA_PAUSE,
|
||||
SERVICE_MEDIA_PLAY,
|
||||
SERVICE_MEDIA_PREVIOUS_TRACK,
|
||||
SERVICE_MEDIA_SEEK,
|
||||
SERVICE_MEDIA_STOP,
|
||||
SERVICE_PLAY_MEDIA,
|
||||
SERVICE_SELECT_SOURCE,
|
||||
SERVICE_SHUFFLE_SET,
|
||||
SERVICE_TOGGLE,
|
||||
SERVICE_TURN_OFF,
|
||||
SERVICE_TURN_ON,
|
||||
SERVICE_VOLUME_MUTE,
|
||||
SERVICE_VOLUME_SET,
|
||||
)
|
||||
from homeassistant.components.media_player.const import (
|
||||
ATTR_INPUT_SOURCE,
|
||||
ATTR_MEDIA_ALBUM_ARTIST,
|
||||
ATTR_MEDIA_ALBUM_NAME,
|
||||
ATTR_MEDIA_ARTIST,
|
||||
ATTR_MEDIA_CONTENT_ID,
|
||||
ATTR_MEDIA_CONTENT_TYPE,
|
||||
ATTR_MEDIA_DURATION,
|
||||
ATTR_MEDIA_POSITION,
|
||||
ATTR_MEDIA_SEEK_POSITION,
|
||||
ATTR_MEDIA_SHUFFLE,
|
||||
ATTR_MEDIA_TITLE,
|
||||
ATTR_MEDIA_TRACK,
|
||||
ATTR_MEDIA_VOLUME_LEVEL,
|
||||
ATTR_MEDIA_VOLUME_MUTED,
|
||||
DOMAIN as MP_DOMAIN,
|
||||
MEDIA_TYPE_MUSIC,
|
||||
MEDIA_TYPE_TVSHOW,
|
||||
)
|
||||
from homeassistant.config_entries import CONN_CLASS_LOCAL_PUSH, SOURCE_USER
|
||||
from homeassistant.const import (
|
||||
ATTR_ENTITY_ID,
|
||||
ATTR_FRIENDLY_NAME,
|
||||
ATTR_SUPPORTED_FEATURES,
|
||||
CONF_HOST,
|
||||
CONF_PASSWORD,
|
||||
CONF_PORT,
|
||||
STATE_ON,
|
||||
STATE_PAUSED,
|
||||
STATE_UNAVAILABLE,
|
||||
)
|
||||
|
||||
from tests.async_mock import patch
|
||||
from tests.common import MockConfigEntry
|
||||
|
||||
TEST_MASTER_ENTITY_NAME = "media_player.forked_daapd_server"
|
||||
TEST_ZONE_ENTITY_NAMES = [
|
||||
"media_player.forked_daapd_output_" + x
|
||||
for x in ["kitchen", "computer", "daapd_fifo"]
|
||||
]
|
||||
|
||||
OPTIONS_DATA = {
|
||||
CONF_LIBRESPOT_JAVA_PORT: "123",
|
||||
CONF_MAX_PLAYLISTS: 8,
|
||||
CONF_TTS_PAUSE_TIME: 0,
|
||||
CONF_TTS_VOLUME: 0.25,
|
||||
}
|
||||
|
||||
SAMPLE_PLAYER_PAUSED = {
|
||||
"state": "pause",
|
||||
"repeat": "off",
|
||||
"consume": False,
|
||||
"shuffle": False,
|
||||
"volume": 20,
|
||||
"item_id": 12322,
|
||||
"item_length_ms": 50,
|
||||
"item_progress_ms": 5,
|
||||
}
|
||||
|
||||
SAMPLE_PLAYER_PLAYING = {
|
||||
"state": "play",
|
||||
"repeat": "off",
|
||||
"consume": False,
|
||||
"shuffle": False,
|
||||
"volume": 50,
|
||||
"item_id": 12322,
|
||||
"item_length_ms": 50,
|
||||
"item_progress_ms": 5,
|
||||
}
|
||||
|
||||
SAMPLE_PLAYER_STOPPED = {
|
||||
"state": "stop",
|
||||
"repeat": "off",
|
||||
"consume": False,
|
||||
"shuffle": False,
|
||||
"volume": 0,
|
||||
"item_id": 12322,
|
||||
"item_length_ms": 50,
|
||||
"item_progress_ms": 5,
|
||||
}
|
||||
|
||||
SAMPLE_TTS_QUEUE = {
|
||||
"version": 833,
|
||||
"count": 1,
|
||||
"items": [
|
||||
{
|
||||
"id": 12322,
|
||||
"position": 0,
|
||||
"track_id": 1234,
|
||||
"title": "Short TTS file",
|
||||
"artist": "Google",
|
||||
"album": "No album",
|
||||
"album_artist": "The xx",
|
||||
"artwork_url": "http://art",
|
||||
"length_ms": 0,
|
||||
"track_number": 1,
|
||||
"media_kind": "music",
|
||||
"uri": "tts_proxy_somefile.mp3",
|
||||
}
|
||||
],
|
||||
}
|
||||
|
||||
SAMPLE_CONFIG = {
|
||||
"websocket_port": 3688,
|
||||
"version": "25.0",
|
||||
"buildoptions": [
|
||||
"ffmpeg",
|
||||
"iTunes XML",
|
||||
"Spotify",
|
||||
"LastFM",
|
||||
"MPD",
|
||||
"Device verification",
|
||||
"Websockets",
|
||||
"ALSA",
|
||||
],
|
||||
}
|
||||
|
||||
SAMPLE_CONFIG_NO_WEBSOCKET = {
|
||||
"websocket_port": 0,
|
||||
"version": "25.0",
|
||||
"buildoptions": [
|
||||
"ffmpeg",
|
||||
"iTunes XML",
|
||||
"Spotify",
|
||||
"LastFM",
|
||||
"MPD",
|
||||
"Device verification",
|
||||
"Websockets",
|
||||
"ALSA",
|
||||
],
|
||||
}
|
||||
|
||||
|
||||
SAMPLE_OUTPUTS_ON = (
|
||||
{
|
||||
"id": "123456789012345",
|
||||
"name": "kitchen",
|
||||
"type": "AirPlay",
|
||||
"selected": True,
|
||||
"has_password": False,
|
||||
"requires_auth": False,
|
||||
"needs_auth_key": False,
|
||||
"volume": 50,
|
||||
},
|
||||
{
|
||||
"id": "0",
|
||||
"name": "Computer",
|
||||
"type": "ALSA",
|
||||
"selected": True,
|
||||
"has_password": False,
|
||||
"requires_auth": False,
|
||||
"needs_auth_key": False,
|
||||
"volume": 19,
|
||||
},
|
||||
{
|
||||
"id": "100",
|
||||
"name": "daapd-fifo",
|
||||
"type": "fifo",
|
||||
"selected": False,
|
||||
"has_password": False,
|
||||
"requires_auth": False,
|
||||
"needs_auth_key": False,
|
||||
"volume": 0,
|
||||
},
|
||||
)
|
||||
|
||||
|
||||
SAMPLE_OUTPUTS_UNSELECTED = [
|
||||
{
|
||||
"id": "123456789012345",
|
||||
"name": "kitchen",
|
||||
"type": "AirPlay",
|
||||
"selected": False,
|
||||
"has_password": False,
|
||||
"requires_auth": False,
|
||||
"needs_auth_key": False,
|
||||
"volume": 0,
|
||||
},
|
||||
{
|
||||
"id": "0",
|
||||
"name": "Computer",
|
||||
"type": "ALSA",
|
||||
"selected": False,
|
||||
"has_password": False,
|
||||
"requires_auth": False,
|
||||
"needs_auth_key": False,
|
||||
"volume": 19,
|
||||
},
|
||||
{
|
||||
"id": "100",
|
||||
"name": "daapd-fifo",
|
||||
"type": "fifo",
|
||||
"selected": False,
|
||||
"has_password": False,
|
||||
"requires_auth": False,
|
||||
"needs_auth_key": False,
|
||||
"volume": 0,
|
||||
},
|
||||
]
|
||||
|
||||
SAMPLE_PIPES = [
|
||||
{
|
||||
"id": 1,
|
||||
"title": "librespot-java",
|
||||
"media_kind": "music",
|
||||
"data_kind": "pipe",
|
||||
"path": "/music/srv/input.pipe",
|
||||
"uri": "library:track:1",
|
||||
}
|
||||
]
|
||||
|
||||
SAMPLE_PLAYLISTS = [{"id": 7, "name": "test_playlist", "uri": "library:playlist:2"}]
|
||||
|
||||
|
||||
@pytest.fixture(name="config_entry")
|
||||
def config_entry_fixture():
|
||||
"""Create hass config_entry fixture."""
|
||||
data = {
|
||||
CONF_HOST: "192.168.1.1",
|
||||
CONF_PORT: "2345",
|
||||
CONF_PASSWORD: "",
|
||||
}
|
||||
return MockConfigEntry(
|
||||
version=1,
|
||||
domain=DOMAIN,
|
||||
title="",
|
||||
data=data,
|
||||
options={CONF_TTS_PAUSE_TIME: 0},
|
||||
system_options={},
|
||||
source=SOURCE_USER,
|
||||
connection_class=CONN_CLASS_LOCAL_PUSH,
|
||||
entry_id=1,
|
||||
)
|
||||
|
||||
|
||||
@pytest.fixture(name="get_request_return_values")
|
||||
async def get_request_return_values_fixture():
|
||||
"""Get request return values we can change later."""
|
||||
return {
|
||||
"config": SAMPLE_CONFIG,
|
||||
"outputs": SAMPLE_OUTPUTS_ON,
|
||||
"player": SAMPLE_PLAYER_PAUSED,
|
||||
"queue": SAMPLE_TTS_QUEUE,
|
||||
}
|
||||
|
||||
|
||||
@pytest.fixture(name="mock_api_object")
|
||||
async def mock_api_object_fixture(hass, config_entry, get_request_return_values):
|
||||
"""Create mock api fixture."""
|
||||
|
||||
async def get_request_side_effect(update_type):
|
||||
if update_type == "outputs":
|
||||
return {"outputs": get_request_return_values["outputs"]}
|
||||
return get_request_return_values[update_type]
|
||||
|
||||
with patch(
|
||||
"homeassistant.components.forked_daapd.media_player.ForkedDaapdAPI",
|
||||
autospec=True,
|
||||
) as mock_api:
|
||||
mock_api.return_value.get_request.side_effect = get_request_side_effect
|
||||
mock_api.return_value.full_url.return_value = ""
|
||||
mock_api.return_value.get_pipes.return_value = SAMPLE_PIPES
|
||||
mock_api.return_value.get_playlists.return_value = SAMPLE_PLAYLISTS
|
||||
config_entry.add_to_hass(hass)
|
||||
await config_entry.async_setup(hass)
|
||||
await hass.async_block_till_done()
|
||||
|
||||
mock_api.return_value.start_websocket_handler.assert_called_once()
|
||||
mock_api.return_value.get_request.assert_called_once()
|
||||
updater_update = mock_api.return_value.start_websocket_handler.call_args[0][2]
|
||||
await updater_update(["player", "outputs", "queue"])
|
||||
await hass.async_block_till_done()
|
||||
|
||||
async def add_to_queue_side_effect(
|
||||
uris, playback=None, playback_from_position=None, clear=None
|
||||
):
|
||||
await updater_update(["queue", "player"])
|
||||
|
||||
mock_api.return_value.add_to_queue.side_effect = (
|
||||
add_to_queue_side_effect # for play_media testing
|
||||
)
|
||||
|
||||
async def pause_side_effect():
|
||||
await updater_update(["player"])
|
||||
|
||||
mock_api.return_value.pause_playback.side_effect = pause_side_effect
|
||||
|
||||
return mock_api.return_value
|
||||
|
||||
|
||||
async def test_unload_config_entry(hass, config_entry, mock_api_object):
|
||||
"""Test the player is removed when the config entry is unloaded."""
|
||||
assert hass.states.get(TEST_MASTER_ENTITY_NAME)
|
||||
assert hass.states.get(TEST_ZONE_ENTITY_NAMES[0])
|
||||
await config_entry.async_unload(hass)
|
||||
assert not hass.states.get(TEST_MASTER_ENTITY_NAME)
|
||||
assert not hass.states.get(TEST_ZONE_ENTITY_NAMES[0])
|
||||
|
||||
|
||||
def test_master_state(hass, mock_api_object):
|
||||
"""Test master state attributes."""
|
||||
state = hass.states.get(TEST_MASTER_ENTITY_NAME)
|
||||
assert state.state == STATE_PAUSED
|
||||
assert state.attributes[ATTR_FRIENDLY_NAME] == "forked-daapd server"
|
||||
assert state.attributes[ATTR_SUPPORTED_FEATURES] == SUPPORTED_FEATURES
|
||||
assert not state.attributes[ATTR_MEDIA_VOLUME_MUTED]
|
||||
assert state.attributes[ATTR_MEDIA_VOLUME_LEVEL] == 0.2
|
||||
assert state.attributes[ATTR_MEDIA_CONTENT_ID] == 12322
|
||||
assert state.attributes[ATTR_MEDIA_CONTENT_TYPE] == MEDIA_TYPE_MUSIC
|
||||
assert state.attributes[ATTR_MEDIA_DURATION] == 0.05
|
||||
assert state.attributes[ATTR_MEDIA_POSITION] == 0.005
|
||||
assert state.attributes[ATTR_MEDIA_TITLE] == "Short TTS file"
|
||||
assert state.attributes[ATTR_MEDIA_ARTIST] == "Google"
|
||||
assert state.attributes[ATTR_MEDIA_ALBUM_NAME] == "No album"
|
||||
assert state.attributes[ATTR_MEDIA_ALBUM_ARTIST] == "The xx"
|
||||
assert state.attributes[ATTR_MEDIA_TRACK] == 1
|
||||
assert not state.attributes[ATTR_MEDIA_SHUFFLE]
|
||||
|
||||
|
||||
async def _service_call(
|
||||
hass, entity_name, service, additional_service_data=None, blocking=True
|
||||
):
|
||||
if additional_service_data is None:
|
||||
additional_service_data = {}
|
||||
return await hass.services.async_call(
|
||||
MP_DOMAIN,
|
||||
service,
|
||||
service_data={ATTR_ENTITY_ID: entity_name, **additional_service_data},
|
||||
blocking=blocking,
|
||||
)
|
||||
|
||||
|
||||
async def test_zone(hass, mock_api_object):
|
||||
"""Test zone attributes and methods."""
|
||||
zone_entity_name = TEST_ZONE_ENTITY_NAMES[0]
|
||||
state = hass.states.get(zone_entity_name)
|
||||
assert state.attributes[ATTR_FRIENDLY_NAME] == "forked-daapd output (kitchen)"
|
||||
assert state.attributes[ATTR_SUPPORTED_FEATURES] == SUPPORTED_FEATURES_ZONE
|
||||
assert state.state == STATE_ON
|
||||
assert state.attributes[ATTR_MEDIA_VOLUME_LEVEL] == 0.5
|
||||
assert not state.attributes[ATTR_MEDIA_VOLUME_MUTED]
|
||||
await _service_call(hass, zone_entity_name, SERVICE_TURN_ON)
|
||||
await _service_call(hass, zone_entity_name, SERVICE_TURN_OFF)
|
||||
await _service_call(hass, zone_entity_name, SERVICE_TOGGLE)
|
||||
await _service_call(
|
||||
hass, zone_entity_name, SERVICE_VOLUME_SET, {ATTR_MEDIA_VOLUME_LEVEL: 0.3}
|
||||
)
|
||||
await _service_call(
|
||||
hass, zone_entity_name, SERVICE_VOLUME_MUTE, {ATTR_MEDIA_VOLUME_MUTED: True}
|
||||
)
|
||||
await _service_call(
|
||||
hass, zone_entity_name, SERVICE_VOLUME_MUTE, {ATTR_MEDIA_VOLUME_MUTED: False}
|
||||
)
|
||||
zone_entity_name = TEST_ZONE_ENTITY_NAMES[2]
|
||||
await _service_call(hass, zone_entity_name, SERVICE_TOGGLE)
|
||||
await _service_call(
|
||||
hass, zone_entity_name, SERVICE_VOLUME_MUTE, {ATTR_MEDIA_VOLUME_MUTED: True}
|
||||
)
|
||||
output_id = SAMPLE_OUTPUTS_ON[0]["id"]
|
||||
initial_volume = SAMPLE_OUTPUTS_ON[0]["volume"]
|
||||
mock_api_object.change_output.assert_any_call(output_id, selected=True)
|
||||
mock_api_object.change_output.assert_any_call(output_id, selected=False)
|
||||
mock_api_object.set_volume.assert_any_call(output_id=output_id, volume=30)
|
||||
mock_api_object.set_volume.assert_any_call(output_id=output_id, volume=0)
|
||||
mock_api_object.set_volume.assert_any_call(
|
||||
output_id=output_id, volume=initial_volume
|
||||
)
|
||||
output_id = SAMPLE_OUTPUTS_ON[2]["id"]
|
||||
mock_api_object.change_output.assert_any_call(output_id, selected=True)
|
||||
|
||||
|
||||
async def test_last_outputs_master(hass, mock_api_object):
|
||||
"""Test restoration of _last_outputs."""
|
||||
# Test turning on sends API call
|
||||
await _service_call(hass, TEST_MASTER_ENTITY_NAME, SERVICE_TURN_ON)
|
||||
assert mock_api_object.change_output.call_count == 0
|
||||
assert mock_api_object.set_enabled_outputs.call_count == 1
|
||||
await _service_call(
|
||||
hass, TEST_MASTER_ENTITY_NAME, SERVICE_TURN_OFF
|
||||
) # should have stored last outputs
|
||||
assert mock_api_object.change_output.call_count == 0
|
||||
assert mock_api_object.set_enabled_outputs.call_count == 2
|
||||
await _service_call(hass, TEST_MASTER_ENTITY_NAME, SERVICE_TURN_ON)
|
||||
assert mock_api_object.change_output.call_count == 3
|
||||
assert mock_api_object.set_enabled_outputs.call_count == 2
|
||||
|
||||
|
||||
async def test_bunch_of_stuff_master(hass, mock_api_object, get_request_return_values):
|
||||
"""Run bunch of stuff."""
|
||||
await _service_call(hass, TEST_MASTER_ENTITY_NAME, SERVICE_TURN_ON)
|
||||
await _service_call(hass, TEST_MASTER_ENTITY_NAME, SERVICE_TURN_OFF)
|
||||
await _service_call(hass, TEST_MASTER_ENTITY_NAME, SERVICE_TOGGLE)
|
||||
await _service_call(
|
||||
hass,
|
||||
TEST_MASTER_ENTITY_NAME,
|
||||
SERVICE_VOLUME_MUTE,
|
||||
{ATTR_MEDIA_VOLUME_MUTED: True},
|
||||
)
|
||||
await _service_call(
|
||||
hass,
|
||||
TEST_MASTER_ENTITY_NAME,
|
||||
SERVICE_VOLUME_MUTE,
|
||||
{ATTR_MEDIA_VOLUME_MUTED: False},
|
||||
)
|
||||
await _service_call(
|
||||
hass,
|
||||
TEST_MASTER_ENTITY_NAME,
|
||||
SERVICE_VOLUME_SET,
|
||||
{ATTR_MEDIA_VOLUME_LEVEL: 0.5},
|
||||
)
|
||||
await _service_call(hass, TEST_MASTER_ENTITY_NAME, SERVICE_MEDIA_PAUSE)
|
||||
await _service_call(hass, TEST_MASTER_ENTITY_NAME, SERVICE_MEDIA_PLAY)
|
||||
await _service_call(hass, TEST_MASTER_ENTITY_NAME, SERVICE_MEDIA_STOP)
|
||||
await _service_call(hass, TEST_MASTER_ENTITY_NAME, SERVICE_MEDIA_PREVIOUS_TRACK)
|
||||
await _service_call(hass, TEST_MASTER_ENTITY_NAME, SERVICE_MEDIA_NEXT_TRACK)
|
||||
await _service_call(
|
||||
hass,
|
||||
TEST_MASTER_ENTITY_NAME,
|
||||
SERVICE_MEDIA_SEEK,
|
||||
{ATTR_MEDIA_SEEK_POSITION: 35},
|
||||
)
|
||||
await _service_call(hass, TEST_MASTER_ENTITY_NAME, SERVICE_CLEAR_PLAYLIST)
|
||||
await _service_call(
|
||||
hass, TEST_MASTER_ENTITY_NAME, SERVICE_SHUFFLE_SET, {ATTR_MEDIA_SHUFFLE: False}
|
||||
)
|
||||
# stop player and run more stuff
|
||||
state = hass.states.get(TEST_MASTER_ENTITY_NAME)
|
||||
assert state.attributes[ATTR_MEDIA_VOLUME_LEVEL] == 0.2
|
||||
get_request_return_values["player"] = SAMPLE_PLAYER_STOPPED
|
||||
updater_update = mock_api_object.start_websocket_handler.call_args[0][2]
|
||||
await updater_update(["player"])
|
||||
await hass.async_block_till_done()
|
||||
# mute from volume==0
|
||||
state = hass.states.get(TEST_MASTER_ENTITY_NAME)
|
||||
assert state.attributes[ATTR_MEDIA_VOLUME_LEVEL] == 0
|
||||
await _service_call(
|
||||
hass,
|
||||
TEST_MASTER_ENTITY_NAME,
|
||||
SERVICE_VOLUME_MUTE,
|
||||
{ATTR_MEDIA_VOLUME_MUTED: True},
|
||||
)
|
||||
# now turn off (stopped and all outputs unselected)
|
||||
get_request_return_values["outputs"] = SAMPLE_OUTPUTS_UNSELECTED
|
||||
await updater_update(["outputs"])
|
||||
await hass.async_block_till_done()
|
||||
# toggle from off
|
||||
await _service_call(hass, TEST_MASTER_ENTITY_NAME, SERVICE_TOGGLE)
|
||||
for output in SAMPLE_OUTPUTS_ON:
|
||||
mock_api_object.change_output.assert_any_call(
|
||||
output["id"], selected=output["selected"], volume=output["volume"],
|
||||
)
|
||||
mock_api_object.set_volume.assert_any_call(volume=0)
|
||||
mock_api_object.set_volume.assert_any_call(volume=SAMPLE_PLAYER_PAUSED["volume"])
|
||||
mock_api_object.set_volume.assert_any_call(volume=50)
|
||||
mock_api_object.set_enabled_outputs.assert_any_call(
|
||||
[output["id"] for output in SAMPLE_OUTPUTS_ON]
|
||||
)
|
||||
mock_api_object.set_enabled_outputs.assert_any_call([])
|
||||
mock_api_object.start_playback.assert_called_once()
|
||||
assert mock_api_object.pause_playback.call_count == 3
|
||||
mock_api_object.stop_playback.assert_called_once()
|
||||
mock_api_object.previous_track.assert_called_once()
|
||||
mock_api_object.next_track.assert_called_once()
|
||||
mock_api_object.seek.assert_called_once()
|
||||
mock_api_object.shuffle.assert_called_once()
|
||||
mock_api_object.clear_queue.assert_called_once()
|
||||
|
||||
|
||||
async def test_async_play_media_from_paused(hass, mock_api_object):
|
||||
"""Test async play media from paused."""
|
||||
initial_state = hass.states.get(TEST_MASTER_ENTITY_NAME)
|
||||
await _service_call(
|
||||
hass,
|
||||
TEST_MASTER_ENTITY_NAME,
|
||||
SERVICE_PLAY_MEDIA,
|
||||
{
|
||||
ATTR_MEDIA_CONTENT_TYPE: MEDIA_TYPE_MUSIC,
|
||||
ATTR_MEDIA_CONTENT_ID: "somefile.mp3",
|
||||
},
|
||||
)
|
||||
state = hass.states.get(TEST_MASTER_ENTITY_NAME)
|
||||
assert state.state == initial_state.state
|
||||
assert state.last_updated > initial_state.last_updated
|
||||
|
||||
|
||||
async def test_async_play_media_from_stopped(
|
||||
hass, get_request_return_values, mock_api_object
|
||||
):
|
||||
"""Test async play media from stopped."""
|
||||
updater_update = mock_api_object.start_websocket_handler.call_args[0][2]
|
||||
|
||||
get_request_return_values["player"] = SAMPLE_PLAYER_STOPPED
|
||||
await updater_update(["player"])
|
||||
await hass.async_block_till_done()
|
||||
initial_state = hass.states.get(TEST_MASTER_ENTITY_NAME)
|
||||
await _service_call(
|
||||
hass,
|
||||
TEST_MASTER_ENTITY_NAME,
|
||||
SERVICE_PLAY_MEDIA,
|
||||
{
|
||||
ATTR_MEDIA_CONTENT_TYPE: MEDIA_TYPE_MUSIC,
|
||||
ATTR_MEDIA_CONTENT_ID: "somefile.mp3",
|
||||
},
|
||||
)
|
||||
state = hass.states.get(TEST_MASTER_ENTITY_NAME)
|
||||
assert state.state == initial_state.state
|
||||
assert state.last_updated > initial_state.last_updated
|
||||
|
||||
|
||||
async def test_async_play_media_unsupported(hass, mock_api_object):
|
||||
"""Test async play media on unsupported media type."""
|
||||
initial_state = hass.states.get(TEST_MASTER_ENTITY_NAME)
|
||||
await _service_call(
|
||||
hass,
|
||||
TEST_MASTER_ENTITY_NAME,
|
||||
SERVICE_PLAY_MEDIA,
|
||||
{
|
||||
ATTR_MEDIA_CONTENT_TYPE: MEDIA_TYPE_TVSHOW,
|
||||
ATTR_MEDIA_CONTENT_ID: "wontwork.mp4",
|
||||
},
|
||||
)
|
||||
state = hass.states.get(TEST_MASTER_ENTITY_NAME)
|
||||
assert state.last_updated == initial_state.last_updated
|
||||
|
||||
|
||||
async def test_async_play_media_tts_timeout(hass, mock_api_object):
|
||||
"""Test async play media with TTS timeout."""
|
||||
mock_api_object.add_to_queue.side_effect = None
|
||||
with patch("homeassistant.components.forked_daapd.media_player.TTS_TIMEOUT", 0):
|
||||
initial_state = hass.states.get(TEST_MASTER_ENTITY_NAME)
|
||||
await _service_call(
|
||||
hass,
|
||||
TEST_MASTER_ENTITY_NAME,
|
||||
SERVICE_PLAY_MEDIA,
|
||||
{
|
||||
ATTR_MEDIA_CONTENT_TYPE: MEDIA_TYPE_MUSIC,
|
||||
ATTR_MEDIA_CONTENT_ID: "somefile.mp3",
|
||||
},
|
||||
)
|
||||
state = hass.states.get(TEST_MASTER_ENTITY_NAME)
|
||||
assert state.state == initial_state.state
|
||||
assert state.last_updated > initial_state.last_updated
|
||||
|
||||
|
||||
async def test_use_pipe_control_with_no_api(hass, mock_api_object):
|
||||
"""Test using pipe control with no api set."""
|
||||
await _service_call(
|
||||
hass,
|
||||
TEST_MASTER_ENTITY_NAME,
|
||||
SERVICE_SELECT_SOURCE,
|
||||
{ATTR_INPUT_SOURCE: "librespot-java (pipe)"},
|
||||
)
|
||||
await _service_call(hass, TEST_MASTER_ENTITY_NAME, SERVICE_MEDIA_PLAY)
|
||||
assert mock_api_object.start_playback.call_count == 0
|
||||
|
||||
|
||||
async def test_clear_source(hass, mock_api_object):
|
||||
"""Test changing source to clear."""
|
||||
await _service_call(
|
||||
hass,
|
||||
TEST_MASTER_ENTITY_NAME,
|
||||
SERVICE_SELECT_SOURCE,
|
||||
{ATTR_INPUT_SOURCE: SOURCE_NAME_CLEAR},
|
||||
)
|
||||
state = hass.states.get(TEST_MASTER_ENTITY_NAME)
|
||||
assert state.attributes[ATTR_INPUT_SOURCE] == SOURCE_NAME_DEFAULT
|
||||
|
||||
|
||||
@pytest.fixture(name="pipe_control_api_object")
|
||||
async def pipe_control_api_object_fixture(
|
||||
hass, config_entry, get_request_return_values, mock_api_object
|
||||
):
|
||||
"""Fixture for mock librespot_java api."""
|
||||
with patch(
|
||||
"homeassistant.components.forked_daapd.media_player.LibrespotJavaAPI",
|
||||
autospec=True,
|
||||
) as pipe_control_api:
|
||||
hass.config_entries.async_update_entry(config_entry, options=OPTIONS_DATA)
|
||||
await hass.async_block_till_done()
|
||||
get_request_return_values["player"] = SAMPLE_PLAYER_PLAYING
|
||||
updater_update = mock_api_object.start_websocket_handler.call_args[0][2]
|
||||
await updater_update(["player"])
|
||||
await hass.async_block_till_done()
|
||||
|
||||
async def pause_side_effect():
|
||||
await updater_update(["player"])
|
||||
|
||||
pipe_control_api.return_value.player_pause.side_effect = pause_side_effect
|
||||
|
||||
await updater_update(["database"]) # load in sources
|
||||
await _service_call(
|
||||
hass,
|
||||
TEST_MASTER_ENTITY_NAME,
|
||||
SERVICE_SELECT_SOURCE,
|
||||
{ATTR_INPUT_SOURCE: "librespot-java (pipe)"},
|
||||
)
|
||||
|
||||
return pipe_control_api.return_value
|
||||
|
||||
|
||||
async def test_librespot_java_stuff(hass, pipe_control_api_object):
|
||||
"""Test options update and librespot-java stuff."""
|
||||
state = hass.states.get(TEST_MASTER_ENTITY_NAME)
|
||||
assert state.attributes[ATTR_INPUT_SOURCE] == "librespot-java (pipe)"
|
||||
# call some basic services
|
||||
await _service_call(hass, TEST_MASTER_ENTITY_NAME, SERVICE_MEDIA_STOP)
|
||||
await _service_call(hass, TEST_MASTER_ENTITY_NAME, SERVICE_MEDIA_PREVIOUS_TRACK)
|
||||
await _service_call(hass, TEST_MASTER_ENTITY_NAME, SERVICE_MEDIA_NEXT_TRACK)
|
||||
await _service_call(hass, TEST_MASTER_ENTITY_NAME, SERVICE_MEDIA_PLAY)
|
||||
pipe_control_api_object.player_pause.assert_called_once()
|
||||
pipe_control_api_object.player_prev.assert_called_once()
|
||||
pipe_control_api_object.player_next.assert_called_once()
|
||||
pipe_control_api_object.player_resume.assert_called_once()
|
||||
# switch away
|
||||
await _service_call(
|
||||
hass,
|
||||
TEST_MASTER_ENTITY_NAME,
|
||||
SERVICE_SELECT_SOURCE,
|
||||
{ATTR_INPUT_SOURCE: SOURCE_NAME_DEFAULT},
|
||||
)
|
||||
state = hass.states.get(TEST_MASTER_ENTITY_NAME)
|
||||
assert state.attributes[ATTR_INPUT_SOURCE] == SOURCE_NAME_DEFAULT
|
||||
|
||||
|
||||
async def test_librespot_java_play_media(hass, pipe_control_api_object):
|
||||
"""Test play media with librespot-java pipe."""
|
||||
initial_state = hass.states.get(TEST_MASTER_ENTITY_NAME)
|
||||
await _service_call(
|
||||
hass,
|
||||
TEST_MASTER_ENTITY_NAME,
|
||||
SERVICE_PLAY_MEDIA,
|
||||
{
|
||||
ATTR_MEDIA_CONTENT_TYPE: MEDIA_TYPE_MUSIC,
|
||||
ATTR_MEDIA_CONTENT_ID: "somefile.mp3",
|
||||
},
|
||||
)
|
||||
state = hass.states.get(TEST_MASTER_ENTITY_NAME)
|
||||
assert state.state == initial_state.state
|
||||
assert state.last_updated > initial_state.last_updated
|
||||
|
||||
|
||||
async def test_librespot_java_play_media_pause_timeout(hass, pipe_control_api_object):
|
||||
"""Test play media with librespot-java pipe."""
|
||||
# test media play with pause timeout
|
||||
pipe_control_api_object.player_pause.side_effect = None
|
||||
with patch(
|
||||
"homeassistant.components.forked_daapd.media_player.CALLBACK_TIMEOUT", 0
|
||||
):
|
||||
initial_state = hass.states.get(TEST_MASTER_ENTITY_NAME)
|
||||
await _service_call(
|
||||
hass,
|
||||
TEST_MASTER_ENTITY_NAME,
|
||||
SERVICE_PLAY_MEDIA,
|
||||
{
|
||||
ATTR_MEDIA_CONTENT_TYPE: MEDIA_TYPE_MUSIC,
|
||||
ATTR_MEDIA_CONTENT_ID: "somefile.mp3",
|
||||
},
|
||||
)
|
||||
state = hass.states.get(TEST_MASTER_ENTITY_NAME)
|
||||
assert state.state == initial_state.state
|
||||
assert state.last_updated > initial_state.last_updated
|
||||
|
||||
|
||||
async def test_unsupported_update(hass, mock_api_object):
|
||||
"""Test unsupported update type."""
|
||||
last_updated = hass.states.get(TEST_MASTER_ENTITY_NAME).last_updated
|
||||
updater_update = mock_api_object.start_websocket_handler.call_args[0][2]
|
||||
await updater_update(["config"])
|
||||
await hass.async_block_till_done()
|
||||
assert hass.states.get(TEST_MASTER_ENTITY_NAME).last_updated == last_updated
|
||||
|
||||
|
||||
async def test_invalid_websocket_port(hass, config_entry):
|
||||
"""Test invalid websocket port on async_init."""
|
||||
with patch(
|
||||
"homeassistant.components.forked_daapd.media_player.ForkedDaapdAPI",
|
||||
autospec=True,
|
||||
) as mock_api:
|
||||
mock_api.return_value.get_request.return_value = SAMPLE_CONFIG_NO_WEBSOCKET
|
||||
config_entry.add_to_hass(hass)
|
||||
await config_entry.async_setup(hass)
|
||||
await hass.async_block_till_done()
|
||||
assert hass.states.get(TEST_MASTER_ENTITY_NAME).state == STATE_UNAVAILABLE
|
||||
|
||||
|
||||
async def test_websocket_disconnect(hass, mock_api_object):
|
||||
"""Test websocket disconnection."""
|
||||
assert hass.states.get(TEST_MASTER_ENTITY_NAME).state != STATE_UNAVAILABLE
|
||||
assert hass.states.get(TEST_ZONE_ENTITY_NAMES[0]).state != STATE_UNAVAILABLE
|
||||
updater_disconnected = mock_api_object.start_websocket_handler.call_args[0][4]
|
||||
updater_disconnected()
|
||||
await hass.async_block_till_done()
|
||||
assert hass.states.get(TEST_MASTER_ENTITY_NAME).state == STATE_UNAVAILABLE
|
||||
assert hass.states.get(TEST_ZONE_ENTITY_NAMES[0]).state == STATE_UNAVAILABLE
|
||||
Reference in new issue
Block a user