Improve Homekit media_player options (#14637)

* Optimize imports

* Optimize name

* Optimize config schema

* Rename mode to feature

* Replace mode with feature_list
This commit is contained in:
cdce8p authored and Paulus Schoutsen committed 2018-05-28 10:26:33 -04:00
1 parent 27f3285d17
commit 6f4dd7b057
7 files changed
+201 -163

No files matched your search

@@ -2,20 +2,17 @@
from unittest.mock import patch, Mock
import pytest
import voluptuous as vol
from homeassistant.core import State
from homeassistant.components.cover import SUPPORT_CLOSE, SUPPORT_OPEN
from homeassistant.components.climate import (
SUPPORT_TARGET_TEMPERATURE_HIGH, SUPPORT_TARGET_TEMPERATURE_LOW)
from homeassistant.components.media_player import (
SUPPORT_TURN_OFF, SUPPORT_TURN_ON)
import homeassistant.components.cover as cover
import homeassistant.components.climate as climate
import homeassistant.components.media_player as media_player
from homeassistant.components.homekit import get_accessory, TYPES
from homeassistant.components.homekit.const import ON_OFF
from homeassistant.components.homekit.const import (
CONF_FEATURE_LIST, FEATURE_ON_OFF)
from homeassistant.const import (
ATTR_CODE, ATTR_DEVICE_CLASS, ATTR_SUPPORTED_FEATURES,
ATTR_UNIT_OF_MEASUREMENT, CONF_MODE, CONF_NAME, TEMP_CELSIUS,
TEMP_FAHRENHEIT)
ATTR_UNIT_OF_MEASUREMENT, CONF_NAME, TEMP_CELSIUS, TEMP_FAHRENHEIT)
def test_not_supported(caplog):
@@ -32,9 +29,9 @@ def test_not_supported(caplog):
def test_not_supported_media_player():
"""Test if mode isn't supported and if no supported modes."""
# selected mode for entity not supported
with pytest.raises(vol.Invalid):
entity_state = State('media_player.demo', 'on')
get_accessory(None, entity_state, 2, {CONF_MODE: [ON_OFF]})
config = {CONF_FEATURE_LIST: {FEATURE_ON_OFF: None}}
entity_state = State('media_player.demo', 'on')
get_accessory(None, entity_state, 2, config) is None
# no supported modes for entity
entity_state = State('media_player.demo', 'on')
@@ -58,14 +55,15 @@ def test_customize_options(config, name):
('Light', 'light.test', 'on', {}, {}),
('Lock', 'lock.test', 'locked', {}, {ATTR_CODE: '1234'}),
('MediaPlayer', 'media_player.test', 'on',
{ATTR_SUPPORTED_FEATURES: SUPPORT_TURN_ON | SUPPORT_TURN_OFF},
{CONF_MODE: [ON_OFF]}),
{ATTR_SUPPORTED_FEATURES: media_player.SUPPORT_TURN_ON |
media_player.SUPPORT_TURN_OFF}, {CONF_FEATURE_LIST:
{FEATURE_ON_OFF: None}}),
('SecuritySystem', 'alarm_control_panel.test', 'armed', {},
{ATTR_CODE: '1234'}),
('Thermostat', 'climate.test', 'auto', {}, {}),
('Thermostat', 'climate.test', 'auto',
{ATTR_SUPPORTED_FEATURES: SUPPORT_TARGET_TEMPERATURE_LOW |
SUPPORT_TARGET_TEMPERATURE_HIGH}, {}),
{ATTR_SUPPORTED_FEATURES: climate.SUPPORT_TARGET_TEMPERATURE_LOW |
climate.SUPPORT_TARGET_TEMPERATURE_HIGH}, {}),
])
def test_types(type_name, entity_id, state, attrs, config):
"""Test if types are associated correctly."""
@@ -82,7 +80,7 @@ def test_types(type_name, entity_id, state, attrs, config):
@pytest.mark.parametrize('type_name, entity_id, state, attrs', [
('GarageDoorOpener', 'cover.garage_door', 'open',
{ATTR_DEVICE_CLASS: 'garage',
ATTR_SUPPORTED_FEATURES: SUPPORT_OPEN | SUPPORT_CLOSE}),
ATTR_SUPPORTED_FEATURES: cover.SUPPORT_OPEN | cover.SUPPORT_CLOSE}),
('WindowCovering', 'cover.set_position', 'open',
{ATTR_SUPPORTED_FEATURES: 4}),
('WindowCoveringBasic', 'cover.open_window', 'open',
@@ -4,9 +4,10 @@ from homeassistant.components.media_player import (
ATTR_MEDIA_VOLUME_MUTED, DOMAIN)
from homeassistant.components.homekit.type_media_players import MediaPlayer
from homeassistant.components.homekit.const import (
ON_OFF, PLAY_PAUSE, PLAY_STOP, TOGGLE_MUTE)
CONF_FEATURE_LIST, FEATURE_ON_OFF, FEATURE_PLAY_PAUSE, FEATURE_PLAY_STOP,
FEATURE_TOGGLE_MUTE)
from homeassistant.const import (
ATTR_ENTITY_ID, ATTR_SUPPORTED_FEATURES, CONF_MODE, SERVICE_MEDIA_PAUSE,
ATTR_ENTITY_ID, ATTR_SUPPORTED_FEATURES, SERVICE_MEDIA_PAUSE,
SERVICE_MEDIA_PLAY, SERVICE_MEDIA_STOP, SERVICE_TURN_OFF, SERVICE_TURN_ON,
SERVICE_VOLUME_MUTE, STATE_IDLE, STATE_OFF, STATE_ON, STATE_PAUSED,
STATE_PLAYING)
@@ -16,7 +17,9 @@ from tests.common import async_mock_service
async def test_media_player_set_state(hass):
"""Test if accessory and HA are updated accordingly."""
config = {CONF_MODE: [ON_OFF, PLAY_PAUSE, PLAY_STOP, TOGGLE_MUTE]}
config = {CONF_FEATURE_LIST: {
FEATURE_ON_OFF: None, FEATURE_PLAY_PAUSE: None,
FEATURE_PLAY_STOP: None, FEATURE_TOGGLE_MUTE: None}}
entity_id = 'media_player.test'
hass.states.async_set(entity_id, None, {ATTR_SUPPORTED_FEATURES: 20873,
@@ -28,32 +31,32 @@ async def test_media_player_set_state(hass):
assert acc.aid == 2
assert acc.category == 8 # Switch
assert acc.chars[ON_OFF].value == 0
assert acc.chars[PLAY_PAUSE].value == 0
assert acc.chars[PLAY_STOP].value == 0
assert acc.chars[TOGGLE_MUTE].value == 0
assert acc.chars[FEATURE_ON_OFF].value == 0
assert acc.chars[FEATURE_PLAY_PAUSE].value == 0
assert acc.chars[FEATURE_PLAY_STOP].value == 0
assert acc.chars[FEATURE_TOGGLE_MUTE].value == 0
hass.states.async_set(entity_id, STATE_ON, {ATTR_MEDIA_VOLUME_MUTED: True})
await hass.async_block_till_done()
assert acc.chars[ON_OFF].value == 1
assert acc.chars[TOGGLE_MUTE].value == 1
assert acc.chars[FEATURE_ON_OFF].value == 1
assert acc.chars[FEATURE_TOGGLE_MUTE].value == 1
hass.states.async_set(entity_id, STATE_OFF)
await hass.async_block_till_done()
assert acc.chars[ON_OFF].value == 0
assert acc.chars[FEATURE_ON_OFF].value == 0
hass.states.async_set(entity_id, STATE_PLAYING)
await hass.async_block_till_done()
assert acc.chars[PLAY_PAUSE].value == 1
assert acc.chars[PLAY_STOP].value == 1
assert acc.chars[FEATURE_PLAY_PAUSE].value == 1
assert acc.chars[FEATURE_PLAY_STOP].value == 1
hass.states.async_set(entity_id, STATE_PAUSED)
await hass.async_block_till_done()
assert acc.chars[PLAY_PAUSE].value == 0
assert acc.chars[FEATURE_PLAY_PAUSE].value == 0
hass.states.async_set(entity_id, STATE_IDLE)
await hass.async_block_till_done()
assert acc.chars[PLAY_STOP].value == 0
assert acc.chars[FEATURE_PLAY_STOP].value == 0
# Set from HomeKit
call_turn_on = async_mock_service(hass, DOMAIN, SERVICE_TURN_ON)
@@ -63,43 +66,51 @@ async def test_media_player_set_state(hass):
call_media_stop = async_mock_service(hass, DOMAIN, SERVICE_MEDIA_STOP)
call_toggle_mute = async_mock_service(hass, DOMAIN, SERVICE_VOLUME_MUTE)
await hass.async_add_job(acc.chars[ON_OFF].client_update_value, True)
await hass.async_add_job(acc.chars[FEATURE_ON_OFF]
.client_update_value, True)
await hass.async_block_till_done()
assert call_turn_on
assert call_turn_on[0].data[ATTR_ENTITY_ID] == entity_id
await hass.async_add_job(acc.chars[ON_OFF].client_update_value, False)
await hass.async_add_job(acc.chars[FEATURE_ON_OFF]
.client_update_value, False)
await hass.async_block_till_done()
assert call_turn_off
assert call_turn_off[0].data[ATTR_ENTITY_ID] == entity_id
await hass.async_add_job(acc.chars[PLAY_PAUSE].client_update_value, True)
await hass.async_add_job(acc.chars[FEATURE_PLAY_PAUSE]
.client_update_value, True)
await hass.async_block_till_done()
assert call_media_play
assert call_media_play[0].data[ATTR_ENTITY_ID] == entity_id
await hass.async_add_job(acc.chars[PLAY_PAUSE].client_update_value, False)
await hass.async_add_job(acc.chars[FEATURE_PLAY_PAUSE]
.client_update_value, False)
await hass.async_block_till_done()
assert call_media_pause
assert call_media_pause[0].data[ATTR_ENTITY_ID] == entity_id
await hass.async_add_job(acc.chars[PLAY_STOP].client_update_value, True)
await hass.async_add_job(acc.chars[FEATURE_PLAY_STOP]
.client_update_value, True)
await hass.async_block_till_done()
assert call_media_play
assert call_media_play[1].data[ATTR_ENTITY_ID] == entity_id
await hass.async_add_job(acc.chars[PLAY_STOP].client_update_value, False)
await hass.async_add_job(acc.chars[FEATURE_PLAY_STOP]
.client_update_value, False)
await hass.async_block_till_done()
assert call_media_stop
assert call_media_stop[0].data[ATTR_ENTITY_ID] == entity_id
await hass.async_add_job(acc.chars[TOGGLE_MUTE].client_update_value, True)
await hass.async_add_job(acc.chars[FEATURE_TOGGLE_MUTE]
.client_update_value, True)
await hass.async_block_till_done()
assert call_toggle_mute
assert call_toggle_mute[0].data[ATTR_ENTITY_ID] == entity_id
assert call_toggle_mute[0].data[ATTR_MEDIA_VOLUME_MUTED] is True
await hass.async_add_job(acc.chars[TOGGLE_MUTE].client_update_value, False)
await hass.async_add_job(acc.chars[FEATURE_TOGGLE_MUTE]
.client_update_value, False)
await hass.async_block_till_done()
assert call_toggle_mute
assert call_toggle_mute[1].data[ATTR_ENTITY_ID] == entity_id
+21 -13
View File
@@ -4,17 +4,18 @@ import voluptuous as vol
from homeassistant.core import State
from homeassistant.components.homekit.const import (
HOMEKIT_NOTIFY_ID, ON_OFF, PLAY_PAUSE, PLAY_STOP, TOGGLE_MUTE)
CONF_FEATURE, CONF_FEATURE_LIST, HOMEKIT_NOTIFY_ID, FEATURE_ON_OFF,
FEATURE_PLAY_PAUSE)
from homeassistant.components.homekit.util import (
convert_to_float, density_to_air_quality, dismiss_setup_message,
show_setup_message, temperature_to_homekit, temperature_to_states,
validate_media_player_modes)
validate_media_player_features)
from homeassistant.components.homekit.util import validate_entity_config \
as vec
from homeassistant.components.persistent_notification import (
ATTR_MESSAGE, ATTR_NOTIFICATION_ID, DOMAIN)
from homeassistant.const import (
ATTR_CODE, ATTR_SUPPORTED_FEATURES, CONF_MODE, CONF_NAME, STATE_UNKNOWN,
ATTR_CODE, ATTR_SUPPORTED_FEATURES, CONF_NAME, STATE_UNKNOWN,
TEMP_CELSIUS, TEMP_FAHRENHEIT)
from tests.common import async_mock_service
@@ -25,7 +26,11 @@ def test_validate_entity_config():
configs = [{'invalid_entity_id': {}}, {'demo.test': 1},
{'demo.test': 'test'}, {'demo.test': [1, 2]},
{'demo.test': None}, {'demo.test': {CONF_NAME: None}},
{'media_player.test': {CONF_MODE: 'invalid_mode'}}]
{'media_player.test': {CONF_FEATURE_LIST: [
{CONF_FEATURE: 'invalid_feature'}]}},
{'media_player.test': {CONF_FEATURE_LIST: [
{CONF_FEATURE: FEATURE_ON_OFF},
{CONF_FEATURE: FEATURE_ON_OFF}]}}, ]
for conf in configs:
with pytest.raises(vol.Invalid):
@@ -45,23 +50,26 @@ def test_validate_entity_config():
{'lock.demo': {ATTR_CODE: '1234'}}
assert vec({'media_player.demo': {}}) == \
{'media_player.demo': {CONF_MODE: []}}
assert vec({'media_player.demo': {CONF_MODE: [ON_OFF]}}) == \
{'media_player.demo': {CONF_MODE: [ON_OFF]}}
{'media_player.demo': {CONF_FEATURE_LIST: {}}}
config = {CONF_FEATURE_LIST: [{CONF_FEATURE: FEATURE_ON_OFF},
{CONF_FEATURE: FEATURE_PLAY_PAUSE}]}
assert vec({'media_player.demo': config}) == \
{'media_player.demo': {CONF_FEATURE_LIST:
{FEATURE_ON_OFF: {}, FEATURE_PLAY_PAUSE: {}}}}
def test_validate_media_player_modes():
def test_validate_media_player_features():
"""Test validate modes for media players."""
config = {}
attrs = {ATTR_SUPPORTED_FEATURES: 20873}
entity_state = State('media_player.demo', 'on', attrs)
validate_media_player_modes(entity_state, config)
assert config == {CONF_MODE: [ON_OFF, PLAY_PAUSE, PLAY_STOP, TOGGLE_MUTE]}
assert validate_media_player_features(entity_state, config) is True
config = {FEATURE_ON_OFF: None}
assert validate_media_player_features(entity_state, config) is True
entity_state = State('media_player.demo', 'on')
config = {CONF_MODE: [ON_OFF]}
with pytest.raises(vol.Invalid):
validate_media_player_modes(entity_state, config)
assert validate_media_player_features(entity_state, config) is False
def test_convert_to_float():