def test_polling(self):
"""Test should_poll property."""
config = validate_config(self.config_children_only)
ump = universal.UniversalMediaPlayer(self.opp, **config)
assert ump.should_poll is False
def test_name(self):
"""Test name property."""
config = validate_config(self.config_children_only)
ump = universal.UniversalMediaPlayer(self.opp, **config)
assert config["name"] == ump.name
def test_active_child_state(self):
"""Test active child state property."""
config = validate_config(self.config_children_only)
ump = universal.UniversalMediaPlayer(self.opp, **config)
ump.entity_id = media_player.ENTITY_ID_FORMAT.format(config["name"])
asyncio.run_coroutine_threadsafe(ump.async_update(), self.opp.loop).result()
assert ump._child_state is None
self.mock_mp_1._state = STATE_PLAYING
self.mock_mp_1.schedule_update_op_state()
self.opp.block_till_done()
asyncio.run_coroutine_threadsafe(ump.async_update(), self.opp.loop).result()
assert self.mock_mp_1.entity_id == ump._child_state.entity_id
self.mock_mp_2._state = STATE_PLAYING
self.mock_mp_2.schedule_update_op_state()
self.opp.block_till_done()
asyncio.run_coroutine_threadsafe(ump.async_update(), self.opp.loop).result()
assert self.mock_mp_1.entity_id == ump._child_state.entity_id
self.mock_mp_1._state = STATE_OFF
self.mock_mp_1.schedule_update_op_state()
self.opp.block_till_done()
asyncio.run_coroutine_threadsafe(ump.async_update(), self.opp.loop).result()
assert self.mock_mp_2.entity_id == ump._child_state.entity_id
def test_master_state(self):
"""Test master state property."""
config = validate_config(self.config_children_only)
ump = universal.UniversalMediaPlayer(self.opp, **config)
assert ump.master_state is None
def test_master_state_with_bad_attrs(self):
"""Test master state property."""
config = copy(self.config_children_and_attr)
config["attributes"]["state"] = "bad.entity_id"
config = validate_config(config)
ump = universal.UniversalMediaPlayer(self.opp, **config)
assert ump.master_state == STATE_OFF
def test_master_state_with_attrs(self):
"""Test master state property."""
config = validate_config(self.config_children_and_attr)
ump = universal.UniversalMediaPlayer(self.opp, **config)
assert ump.master_state == STATE_OFF
self.opp.states.set(self.mock_state_switch_id, STATE_ON)
assert ump.master_state == STATE_ON
def test_sound_mode_list_children_and_attr(self):
"""Test sound mode list property w/ children and attrs."""
config = validate_config(self.config_children_and_attr)
ump = universal.UniversalMediaPlayer(self.opp, **config)
assert ump.sound_mode_list == "['music', 'movie']"
self.opp.states.set(self.mock_sound_mode_list_id, ["music", "movie", "game"])
assert ump.sound_mode_list == "['music', 'movie', 'game']"
def test_volume_level_children_and_attr(self):
"""Test volume level property w/ children and attrs."""
config = validate_config(self.config_children_and_attr)
ump = universal.UniversalMediaPlayer(self.opp, **config)
assert ump.volume_level == 0
self.opp.states.set(self.mock_volume_id, 100)
assert ump.volume_level == 100
def test_is_volume_muted_children_and_attr(self):
"""Test is volume muted property w/ children and attrs."""
config = validate_config(self.config_children_and_attr)
ump = universal.UniversalMediaPlayer(self.opp, **config)
assert not ump.is_volume_muted
self.opp.states.set(self.mock_mute_switch_id, STATE_ON)
assert ump.is_volume_muted
def test_sound_mode_children_and_attr(self):
"""Test sound modeproperty w/ children and attrs."""
config = validate_config(self.config_children_and_attr)
ump = universal.UniversalMediaPlayer(self.opp, **config)
assert ump.sound_mode == "music"
self.opp.states.set(self.mock_sound_mode_id, "movie")
assert ump.sound_mode == "movie"
def test_source_children_and_attr(self):
"""Test source property w/ children and attrs."""
config = validate_config(self.config_children_and_attr)
ump = universal.UniversalMediaPlayer(self.opp, **config)
assert ump.source == "dvd"
self.opp.states.set(self.mock_source_id, "htpc")
assert ump.source == "htpc"
def test_source_list_children_and_attr(self):
"""Test source list property w/ children and attrs."""
config = validate_config(self.config_children_and_attr)
ump = universal.UniversalMediaPlayer(self.opp, **config)
assert ump.source_list == "['dvd', 'htpc']"
self.opp.states.set(self.mock_source_list_id, ["dvd", "htpc", "game"])
assert ump.source_list == "['dvd', 'htpc', 'game']"
def test_supported_features_children_and_cmds(self):
"""Test supported media commands with children and attrs."""
config = copy(self.config_children_and_attr)
excmd = {"service": "media_player.test", "data": {}}
config["commands"] = {
"turn_on": excmd,
"turn_off": excmd,
"volume_up": excmd,
"volume_down": excmd,
"volume_mute": excmd,
"volume_set": excmd,
"select_sound_mode": excmd,
"select_source": excmd,
"repeat_set": excmd,
"shuffle_set": excmd,
"media_play": excmd,
"media_pause": excmd,
"media_stop": excmd,
"media_next_track": excmd,
"media_previous_track": excmd,
"toggle": excmd,
"play_media": excmd,
"clear_playlist": excmd,
}
config = validate_config(config)
ump = universal.UniversalMediaPlayer(self.opp, **config)
ump.entity_id = media_player.ENTITY_ID_FORMAT.format(config["name"])
asyncio.run_coroutine_threadsafe(ump.async_update(), self.opp.loop).result()
self.mock_mp_1._state = STATE_PLAYING
self.mock_mp_1.schedule_update_op_state()
self.opp.block_till_done()
asyncio.run_coroutine_threadsafe(ump.async_update(), self.opp.loop).result()
check_flags = (
universal.SUPPORT_TURN_ON
| universal.SUPPORT_TURN_OFF
| universal.SUPPORT_VOLUME_STEP
| universal.SUPPORT_VOLUME_MUTE
| universal.SUPPORT_SELECT_SOUND_MODE
| universal.SUPPORT_SELECT_SOURCE
| universal.SUPPORT_REPEAT_SET
| universal.SUPPORT_SHUFFLE_SET
| universal.SUPPORT_VOLUME_SET
| universal.SUPPORT_PLAY
| universal.SUPPORT_PAUSE
| universal.SUPPORT_STOP
| universal.SUPPORT_NEXT_TRACK
| universal.SUPPORT_PREVIOUS_TRACK
| universal.SUPPORT_PLAY_MEDIA
| universal.SUPPORT_CLEAR_PLAYLIST
)
assert check_flags == ump.supported_features
def test_state_children_only(self):
"""Test media player state with only children."""
config = validate_config(self.config_children_only)
ump = universal.UniversalMediaPlayer(self.opp, **config)
ump.entity_id = media_player.ENTITY_ID_FORMAT.format(config["name"])
asyncio.run_coroutine_threadsafe(ump.async_update(), self.opp.loop).result()
assert ump.state, STATE_OFF
self.mock_mp_1._state = STATE_PLAYING
self.mock_mp_1.schedule_update_op_state()
self.opp.block_till_done()
asyncio.run_coroutine_threadsafe(ump.async_update(), self.opp.loop).result()
assert ump.state == STATE_PLAYING
def test_service_call_no_active_child(self):
"""Test a service call to children with no active child."""
config = validate_config(self.config_children_and_attr)
ump = universal.UniversalMediaPlayer(self.opp, **config)
ump.entity_id = media_player.ENTITY_ID_FORMAT.format(config["name"])
asyncio.run_coroutine_threadsafe(ump.async_update(), self.opp.loop).result()
self.mock_mp_1._state = STATE_OFF
self.mock_mp_1.schedule_update_op_state()
self.mock_mp_2._state = STATE_OFF
self.mock_mp_2.schedule_update_op_state()
self.opp.block_till_done()
asyncio.run_coroutine_threadsafe(ump.async_update(), self.opp.loop).result()
asyncio.run_coroutine_threadsafe(ump.async_turn_off(), self.opp.loop).result()
assert len(self.mock_mp_1.service_calls["turn_off"]) == 0
assert len(self.mock_mp_2.service_calls["turn_off"]) == 0
def test_service_call_to_command(self):
"""Test service call to command."""
config = copy(self.config_children_only)
config["commands"] = {"turn_off": {"service": "test.turn_off", "data": {}}}
config = validate_config(config)
service = mock_service(self.opp, "test", "turn_off")
ump = universal.UniversalMediaPlayer(self.opp, **config)
ump.entity_id = media_player.ENTITY_ID_FORMAT.format(config["name"])
asyncio.run_coroutine_threadsafe(ump.async_update(), self.opp.loop).result()
self.mock_mp_2._state = STATE_PLAYING
self.mock_mp_2.schedule_update_op_state()
self.opp.block_till_done()
asyncio.run_coroutine_threadsafe(ump.async_update(), self.opp.loop).result()
asyncio.run_coroutine_threadsafe(ump.async_turn_off(), self.opp.loop).result()
assert len(service) == 1
def test_supported_features_play_pause(self):
"""Test supported media commands with play_pause function."""
config = copy(self.config_children_and_attr)
excmd = {"service": "media_player.test", "data": {"entity_id": "test"}}
config["commands"] = {"media_play_pause": excmd}
config = validate_config(config)
ump = universal.UniversalMediaPlayer(self.opp, **config)
ump.entity_id = media_player.ENTITY_ID_FORMAT.format(config["name"])
asyncio.run_coroutine_threadsafe(ump.async_update(), self.opp.loop).result()
self.mock_mp_1._state = STATE_PLAYING
self.mock_mp_1.schedule_update_op_state()
self.opp.block_till_done()
asyncio.run_coroutine_threadsafe(ump.async_update(), self.opp.loop).result()
check_flags = universal.SUPPORT_PLAY | universal.SUPPORT_PAUSE
assert check_flags == ump.supported_features
def test_media_image_url(self):
"""Test media_image_url property."""
test_url = "test_url"
config = validate_config(self.config_children_only)
ump = universal.UniversalMediaPlayer(self.opp, **config)
ump.entity_id = media_player.ENTITY_ID_FORMAT.format(config["name"])
asyncio.run_coroutine_threadsafe(ump.async_update(), self.opp.loop).result()
assert ump.media_image_url is None
self.mock_mp_1._state = STATE_PLAYING
self.mock_mp_1._media_image_url = test_url
self.mock_mp_1.schedule_update_op_state()
self.opp.block_till_done()
asyncio.run_coroutine_threadsafe(ump.async_update(), self.opp.loop).result()
# mock_mp_1 will convert the url to the api proxy url. This test
# ensures ump passes through the same url without an additional proxy.
assert self.mock_mp_1.entity_picture == ump.entity_picture
def test_is_volume_muted_children_only(self):
"""Test is volume muted property w/ children only."""
config = validate_config(self.config_children_only)
ump = universal.UniversalMediaPlayer(self.opp, **config)
ump.entity_id = media_player.ENTITY_ID_FORMAT.format(config["name"])
asyncio.run_coroutine_threadsafe(ump.async_update(), self.opp.loop).result()
assert not ump.is_volume_muted
self.mock_mp_1._state = STATE_PLAYING
self.mock_mp_1.schedule_update_op_state()
self.opp.block_till_done()
asyncio.run_coroutine_threadsafe(ump.async_update(), self.opp.loop).result()
assert not ump.is_volume_muted
self.mock_mp_1._is_volume_muted = True
self.mock_mp_1.schedule_update_op_state()
self.opp.block_till_done()
asyncio.run_coroutine_threadsafe(ump.async_update(), self.opp.loop).result()
assert ump.is_volume_muted
def test_volume_level(self):
"""Test volume level property."""
config = validate_config(self.config_children_only)
ump = universal.UniversalMediaPlayer(self.opp, **config)
ump.entity_id = media_player.ENTITY_ID_FORMAT.format(config["name"])
asyncio.run_coroutine_threadsafe(ump.async_update(), self.opp.loop).result()
assert ump.volume_level is None
self.mock_mp_1._state = STATE_PLAYING
self.mock_mp_1.schedule_update_op_state()
self.opp.block_till_done()
asyncio.run_coroutine_threadsafe(ump.async_update(), self.opp.loop).result()
assert ump.volume_level == 0
self.mock_mp_1._volume_level = 1
self.mock_mp_1.schedule_update_op_state()
self.opp.block_till_done()
asyncio.run_coroutine_threadsafe(ump.async_update(), self.opp.loop).result()
assert ump.volume_level == 1
def test_service_call_to_child(self):
"""Test service calls that should be routed to a child."""
config = validate_config(self.config_children_only)
ump = universal.UniversalMediaPlayer(self.opp, **config)
ump.entity_id = media_player.ENTITY_ID_FORMAT.format(config["name"])
asyncio.run_coroutine_threadsafe(ump.async_update(), self.opp.loop).result()
self.mock_mp_2._state = STATE_PLAYING
self.mock_mp_2.schedule_update_op_state()
self.opp.block_till_done()
asyncio.run_coroutine_threadsafe(ump.async_update(), self.opp.loop).result()
asyncio.run_coroutine_threadsafe(ump.async_turn_off(), self.opp.loop).result()
assert len(self.mock_mp_2.service_calls["turn_off"]) == 1
asyncio.run_coroutine_threadsafe(ump.async_turn_on(), self.opp.loop).result()
assert len(self.mock_mp_2.service_calls["turn_on"]) == 1
asyncio.run_coroutine_threadsafe(
ump.async_mute_volume(True), self.opp.loop
).result()
assert len(self.mock_mp_2.service_calls["mute_volume"]) == 1
asyncio.run_coroutine_threadsafe(
ump.async_set_volume_level(0.5), self.opp.loop
).result()
assert len(self.mock_mp_2.service_calls["set_volume_level"]) == 1
asyncio.run_coroutine_threadsafe(ump.async_media_play(), self.opp.loop).result()
assert len(self.mock_mp_2.service_calls["media_play"]) == 1
asyncio.run_coroutine_threadsafe(
ump.async_media_pause(), self.opp.loop
).result()
assert len(self.mock_mp_2.service_calls["media_pause"]) == 1
asyncio.run_coroutine_threadsafe(ump.async_media_stop(), self.opp.loop).result()
assert len(self.mock_mp_2.service_calls["media_stop"]) == 1
asyncio.run_coroutine_threadsafe(
ump.async_media_previous_track(), self.opp.loop
).result()
assert len(self.mock_mp_2.service_calls["media_previous_track"]) == 1
asyncio.run_coroutine_threadsafe(
ump.async_media_next_track(), self.opp.loop
).result()
assert len(self.mock_mp_2.service_calls["media_next_track"]) == 1
asyncio.run_coroutine_threadsafe(
ump.async_media_seek(100), self.opp.loop
).result()
assert len(self.mock_mp_2.service_calls["media_seek"]) == 1
asyncio.run_coroutine_threadsafe(
ump.async_play_media("movie", "batman"), self.opp.loop
).result()
assert len(self.mock_mp_2.service_calls["play_media"]) == 1
asyncio.run_coroutine_threadsafe(ump.async_volume_up(), self.opp.loop).result()
assert len(self.mock_mp_2.service_calls["volume_up"]) == 1
asyncio.run_coroutine_threadsafe(
ump.async_volume_down(), self.opp.loop
).result()
assert len(self.mock_mp_2.service_calls["volume_down"]) == 1
asyncio.run_coroutine_threadsafe(
ump.async_media_play_pause(), self.opp.loop
).result()
assert len(self.mock_mp_2.service_calls["media_play_pause"]) == 1
asyncio.run_coroutine_threadsafe(
ump.async_select_sound_mode("music"), self.opp.loop
).result()
assert len(self.mock_mp_2.service_calls["select_sound_mode"]) == 1
asyncio.run_coroutine_threadsafe(
ump.async_select_source("dvd"), self.opp.loop
).result()
assert len(self.mock_mp_2.service_calls["select_source"]) == 1
asyncio.run_coroutine_threadsafe(
ump.async_clear_playlist(), self.opp.loop
).result()
assert len(self.mock_mp_2.service_calls["clear_playlist"]) == 1
asyncio.run_coroutine_threadsafe(
ump.async_set_repeat(True), self.opp.loop
).result()
assert len(self.mock_mp_2.service_calls["repeat_set"]) == 1
asyncio.run_coroutine_threadsafe(
ump.async_set_shuffle(True), self.opp.loop
).result()
assert len(self.mock_mp_2.service_calls["shuffle_set"]) == 1
asyncio.run_coroutine_threadsafe(ump.async_toggle(), self.opp.loop).result()
assert len(self.mock_mp_2.service_calls["toggle"]) == 1