async def test_polling(hass):
"""Test should_poll property."""
config = validate_config(CONFIG_CHILDREN_ONLY)
ump = universal.UniversalMediaPlayer(hass, **config)
assert ump.should_poll is False
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": {"entity_id": "test"}}
config["commands"] = {
"turn_on": excmd,
"turn_off": excmd,
"volume_up": excmd,
"volume_down": excmd,
"volume_mute": excmd,
"volume_set": excmd,
"select_source": excmd,
"shuffle_set": excmd,
}
config = validate_config(config)
ump = universal.UniversalMediaPlayer(self.hass, **config)
ump.entity_id = media_player.ENTITY_ID_FORMAT.format(config["name"])
run_coroutine_threadsafe(ump.async_update(), self.hass.loop).result()
self.mock_mp_1._state = STATE_PLAYING
self.mock_mp_1.schedule_update_ha_state()
self.hass.block_till_done()
run_coroutine_threadsafe(ump.async_update(), self.hass.loop).result()
check_flags = (universal.SUPPORT_TURN_ON
| universal.SUPPORT_TURN_OFF
| universal.SUPPORT_VOLUME_STEP
| universal.SUPPORT_VOLUME_MUTE
| universal.SUPPORT_SELECT_SOURCE
| universal.SUPPORT_SHUFFLE_SET
| universal.SUPPORT_VOLUME_SET)
assert check_flags == ump.supported_features
async def test_name(hass):
"""Test name property."""
config = validate_config(CONFIG_CHILDREN_ONLY)
ump = universal.UniversalMediaPlayer(hass, **config)
assert config["name"] == ump.name
def test_state_with_children_and_attrs(self):
"""Test media player with children and master state."""
config = validate_config(self.config_children_and_attr)
ump = universal.UniversalMediaPlayer(self.hass, **config)
ump.entity_id = media_player.ENTITY_ID_FORMAT.format(config["name"])
asyncio.run_coroutine_threadsafe(ump.async_update(),
self.hass.loop).result()
assert STATE_OFF == ump.state
self.hass.states.set(self.mock_state_switch_id, STATE_ON)
asyncio.run_coroutine_threadsafe(ump.async_update(),
self.hass.loop).result()
assert STATE_ON == ump.state
self.mock_mp_1._state = STATE_PLAYING
self.mock_mp_1.schedule_update_ha_state()
self.hass.block_till_done()
asyncio.run_coroutine_threadsafe(ump.async_update(),
self.hass.loop).result()
assert STATE_PLAYING == ump.state
self.hass.states.set(self.mock_state_switch_id, STATE_OFF)
asyncio.run_coroutine_threadsafe(ump.async_update(),
self.hass.loop).result()
assert STATE_OFF == ump.state
async def test_master_state(hass):
"""Test master state property."""
config = validate_config(CONFIG_CHILDREN_ONLY)
ump = universal.UniversalMediaPlayer(hass, **config)
assert ump.master_state is None
def test_master_state(self):
"""Test master state property."""
config = validate_config(self.config_children_only)
ump = universal.UniversalMediaPlayer(self.hass, **config)
assert ump.master_state is None
async def test_active_child_state(hass, mock_states):
"""Test active child state property."""
config = validate_config(CONFIG_CHILDREN_ONLY)
ump = universal.UniversalMediaPlayer(hass, **config)
ump.entity_id = media_player.ENTITY_ID_FORMAT.format(config["name"])
await ump.async_update()
assert ump._child_state is None
mock_states.mock_mp_1._state = STATE_PLAYING
mock_states.mock_mp_1.async_schedule_update_ha_state()
await hass.async_block_till_done()
await ump.async_update()
assert mock_states.mock_mp_1.entity_id == ump._child_state.entity_id
mock_states.mock_mp_2._state = STATE_PLAYING
mock_states.mock_mp_2.async_schedule_update_ha_state()
await hass.async_block_till_done()
await ump.async_update()
assert mock_states.mock_mp_1.entity_id == ump._child_state.entity_id
mock_states.mock_mp_1._state = STATE_PAUSED
mock_states.mock_mp_1.async_schedule_update_ha_state()
await hass.async_block_till_done()
await ump.async_update()
assert mock_states.mock_mp_2.entity_id == ump._child_state.entity_id
mock_states.mock_mp_1._state = STATE_OFF
mock_states.mock_mp_1.async_schedule_update_ha_state()
await hass.async_block_till_done()
await ump.async_update()
assert mock_states.mock_mp_2.entity_id == ump._child_state.entity_id
def test_active_child_state(self):
"""Test active child state property."""
config = validate_config(self.config_children_only)
ump = universal.UniversalMediaPlayer(self.hass, **config)
ump.entity_id = media_player.ENTITY_ID_FORMAT.format(config["name"])
asyncio.run_coroutine_threadsafe(ump.async_update(), self.hass.loop).result()
assert ump._child_state is None
self.mock_mp_1._state = STATE_PLAYING
self.mock_mp_1.schedule_update_ha_state()
self.hass.block_till_done()
asyncio.run_coroutine_threadsafe(ump.async_update(), self.hass.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_ha_state()
self.hass.block_till_done()
asyncio.run_coroutine_threadsafe(ump.async_update(), self.hass.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_ha_state()
self.hass.block_till_done()
asyncio.run_coroutine_threadsafe(ump.async_update(), self.hass.loop).result()
assert self.mock_mp_2.entity_id == ump._child_state.entity_id
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.hass, "test", "turn_off")
ump = universal.UniversalMediaPlayer(self.hass, **config)
ump.entity_id = media_player.ENTITY_ID_FORMAT.format(config["name"])
asyncio.run_coroutine_threadsafe(ump.async_update(),
self.hass.loop).result()
self.mock_mp_2._state = STATE_PLAYING
self.mock_mp_2.schedule_update_ha_state()
self.hass.block_till_done()
asyncio.run_coroutine_threadsafe(ump.async_update(),
self.hass.loop).result()
asyncio.run_coroutine_threadsafe(ump.async_turn_off(),
self.hass.loop).result()
assert 1 == len(service)
def test_polling(self):
"""Test should_poll property."""
config = validate_config(self.config_children_only)
ump = universal.UniversalMediaPlayer(self.hass, **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.hass, **config)
assert config["name"] == ump.name
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.hass, **config)
assert STATE_OFF == ump.master_state
async def test_supported_features_children_and_cmds(
hass, config_children_and_attr, mock_states
):
"""Test supported media commands with children and attrs."""
config = copy(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(hass, **config)
ump.entity_id = media_player.ENTITY_ID_FORMAT.format(config["name"])
await ump.async_update()
mock_states.mock_mp_1._state = STATE_PLAYING
mock_states.mock_mp_1.async_schedule_update_ha_state()
await hass.async_block_till_done()
await ump.async_update()
check_flags = (
MediaPlayerEntityFeature.TURN_ON
| MediaPlayerEntityFeature.TURN_OFF
| MediaPlayerEntityFeature.VOLUME_STEP
| MediaPlayerEntityFeature.VOLUME_MUTE
| MediaPlayerEntityFeature.SELECT_SOUND_MODE
| MediaPlayerEntityFeature.SELECT_SOURCE
| MediaPlayerEntityFeature.REPEAT_SET
| MediaPlayerEntityFeature.SHUFFLE_SET
| MediaPlayerEntityFeature.VOLUME_SET
| MediaPlayerEntityFeature.PLAY
| MediaPlayerEntityFeature.PAUSE
| MediaPlayerEntityFeature.STOP
| MediaPlayerEntityFeature.NEXT_TRACK
| MediaPlayerEntityFeature.PREVIOUS_TRACK
| MediaPlayerEntityFeature.PLAY_MEDIA
| MediaPlayerEntityFeature.CLEAR_PLAYLIST
)
assert check_flags == ump.supported_features
async def test_master_state_with_attrs(hass, config_children_and_attr, mock_states):
"""Test master state property."""
config = validate_config(config_children_and_attr)
ump = universal.UniversalMediaPlayer(hass, **config)
assert ump.master_state == STATE_OFF
hass.states.async_set(mock_states.mock_state_switch_id, STATE_ON)
assert ump.master_state == STATE_ON
def test_master_state_with_attrs(self):
"""Test master state property."""
config = validate_config(self.config_children_and_attr)
ump = universal.UniversalMediaPlayer(self.hass, **config)
assert STATE_OFF == ump.master_state
self.hass.states.set(self.mock_state_switch_id, STATE_ON)
assert STATE_ON == ump.master_state
async def test_source_children_and_attr(hass, config_children_and_attr, mock_states):
"""Test source property w/ children and attrs."""
config = validate_config(config_children_and_attr)
ump = universal.UniversalMediaPlayer(hass, **config)
assert ump.source == "dvd"
hass.states.async_set(mock_states.mock_source_id, "htpc")
assert ump.source == "htpc"
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.hass, **config)
assert ump.sound_mode_list == "['music', 'movie']"
self.hass.states.set(self.mock_sound_mode_list_id, ["music", "movie", "game"])
assert ump.sound_mode_list == "['music', 'movie', 'game']"
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.hass, **config)
assert not ump.is_volume_muted
self.hass.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.hass, **config)
assert ump.sound_mode == "music"
self.hass.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.hass, **config)
assert "dvd" == ump.source
self.hass.states.set(self.mock_source_id, "htpc")
assert "htpc" == ump.source
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.hass, **config)
assert 0 == ump.volume_level
self.hass.states.set(self.mock_volume_id, 100)
assert 100 == ump.volume_level
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.hass, **config)
assert "['dvd', 'htpc']" == ump.source_list
self.hass.states.set(self.mock_source_list_id, ["dvd", "htpc", "game"])
assert "['dvd', 'htpc', 'game']" == ump.source_list
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.hass, **config)
ump.entity_id = media_player.ENTITY_ID_FORMAT.format(config["name"])
asyncio.run_coroutine_threadsafe(ump.async_update(),
self.hass.loop).result()
self.mock_mp_1._state = STATE_PLAYING
self.mock_mp_1.schedule_update_ha_state()
self.hass.block_till_done()
asyncio.run_coroutine_threadsafe(ump.async_update(),
self.hass.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
async def test_volume_level_children_and_attr(hass, config_children_and_attr,
mock_states):
"""Test volume level property w/ children and attrs."""
config = validate_config(config_children_and_attr)
ump = universal.UniversalMediaPlayer(hass, **config)
assert ump.volume_level == 0
hass.states.async_set(mock_states.mock_volume_id, 100)
assert ump.volume_level == 100
async def test_sound_mode_children_and_attr(hass, config_children_and_attr,
mock_states):
"""Test sound modeproperty w/ children and attrs."""
config = validate_config(config_children_and_attr)
ump = universal.UniversalMediaPlayer(hass, **config)
assert ump.sound_mode == "music"
hass.states.async_set(mock_states.mock_sound_mode_id, "movie")
assert ump.sound_mode == "movie"
async def test_is_volume_muted_children_and_attr(hass,
config_children_and_attr,
mock_states):
"""Test is volume muted property w/ children and attrs."""
config = validate_config(config_children_and_attr)
ump = universal.UniversalMediaPlayer(hass, **config)
assert not ump.is_volume_muted
hass.states.async_set(mock_states.mock_mute_switch_id, STATE_ON)
assert ump.is_volume_muted
async def test_source_list_children_and_attr(hass, config_children_and_attr,
mock_states):
"""Test source list property w/ children and attrs."""
config = validate_config(config_children_and_attr)
ump = universal.UniversalMediaPlayer(hass, **config)
assert ump.source_list == "['dvd', 'htpc']"
hass.states.async_set(mock_states.mock_source_list_id,
["dvd", "htpc", "game"])
assert ump.source_list == "['dvd', 'htpc', 'game']"
def test_master_state_with_template(self):
"""Test the state_template option."""
config = copy(self.config_children_and_attr)
self.hass.states.set("input_boolean.test", STATE_OFF)
templ = ('{% if states.input_boolean.test.state == "off" %}on'
"{% else %}{{ states.media_player.mock1.state }}{% endif %}")
config["state_template"] = templ
config = validate_config(config)
ump = universal.UniversalMediaPlayer(self.hass, **config)
assert STATE_ON == ump.master_state
self.hass.states.set("input_boolean.test", STATE_ON)
assert STATE_OFF == ump.master_state
async def test_state_children_only(hass, mock_states):
"""Test media player state with only children."""
config = validate_config(CONFIG_CHILDREN_ONLY)
ump = universal.UniversalMediaPlayer(hass, **config)
ump.entity_id = media_player.ENTITY_ID_FORMAT.format(config["name"])
await ump.async_update()
assert ump.state, STATE_OFF
mock_states.mock_mp_1._state = STATE_PLAYING
mock_states.mock_mp_1.async_schedule_update_ha_state()
await hass.async_block_till_done()
await ump.async_update()
assert ump.state == STATE_PLAYING
def test_state_children_only(self):
"""Test media player state with only children."""
config = validate_config(self.config_children_only)
ump = universal.UniversalMediaPlayer(self.hass, **config)
ump.entity_id = media_player.ENTITY_ID_FORMAT.format(config["name"])
asyncio.run_coroutine_threadsafe(ump.async_update(), self.hass.loop).result()
assert ump.state, STATE_OFF
self.mock_mp_1._state = STATE_PLAYING
self.mock_mp_1.schedule_update_ha_state()
self.hass.block_till_done()
asyncio.run_coroutine_threadsafe(ump.async_update(), self.hass.loop).result()
assert STATE_PLAYING == ump.state
