jeans/core
jeans/core
1
0
Fork 0
mirror of https://github.com/home-assistant/core.git synced 2025-07-24 05:37:44 +00:00
Code Issues Packages Projects Releases Wiki Activity

Use supported_color_modes in google_assistant (#49176)

Browse Source 
* Use supported_color_modes in google_assistant

* Fix tests
This commit is contained in:
Erik Montnemery 2021-04-14 09:18:22 +02:00 committed by GitHub
parent 44beff31c2
commit 1a5068f71d
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
4 changed files with 108 additions and 90 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
homeassistant/components/google_assistant/helpers.py
View File

@ -408,7 +408,8 @@ class GoogleEntity:
state = self.state
domain = state.domain
features = state.attributes.get(ATTR_SUPPORTED_FEATURES, 0)
attributes = state.attributes
features = attributes.get(ATTR_SUPPORTED_FEATURES, 0)
if not isinstance(features, int):
_LOGGER.warning(
@ -423,7 +424,7 @@ class GoogleEntity:
self._traits = [
Trait(self.hass, state, self.config)
for Trait in trait.TRAITS
if Trait.supported(domain, features, device_class)
if Trait.supported(domain, features, device_class, attributes)
]
return self._traits

56
homeassistant/components/google_assistant/trait.py
View File

@ -212,10 +212,11 @@ class BrightnessTrait(_Trait):
commands = [COMMAND_BRIGHTNESS_ABSOLUTE]
@staticmethod
def supported(domain, features, device_class):
def supported(domain, features, device_class, attributes):
"""Test if state is supported."""
color_modes = attributes.get(light.ATTR_SUPPORTED_COLOR_MODES, [])
if domain == light.DOMAIN:
return features & light.SUPPORT_BRIGHTNESS
return any(mode in color_modes for mode in light.COLOR_MODES_BRIGHTNESS)
return False
@ -267,7 +268,7 @@ class CameraStreamTrait(_Trait):
stream_info = None
@staticmethod
def supported(domain, features, device_class):
def supported(domain, features, device_class, _):
"""Test if state is supported."""
if domain == camera.DOMAIN:
return features & camera.SUPPORT_STREAM
@ -308,7 +309,7 @@ class OnOffTrait(_Trait):
commands = [COMMAND_ONOFF]
@staticmethod
def supported(domain, features, device_class):
def supported(domain, features, device_class, _):
"""Test if state is supported."""
return domain in (
group.DOMAIN,
@ -362,23 +363,26 @@ class ColorSettingTrait(_Trait):
commands = [COMMAND_COLOR_ABSOLUTE]
@staticmethod
def supported(domain, features, device_class):
def supported(domain, features, device_class, attributes):
"""Test if state is supported."""
if domain != light.DOMAIN:
return False
return features & light.SUPPORT_COLOR_TEMP or features & light.SUPPORT_COLOR
color_modes = attributes.get(light.ATTR_SUPPORTED_COLOR_MODES, [])
return light.COLOR_MODE_COLOR_TEMP in color_modes or any(
mode in color_modes for mode in light.COLOR_MODES_COLOR
)
def sync_attributes(self):
"""Return color temperature attributes for a sync request."""
attrs = self.state.attributes
features = attrs.get(ATTR_SUPPORTED_FEATURES, 0)
color_modes = attrs.get(light.ATTR_SUPPORTED_COLOR_MODES, [])
response = {}
if features & light.SUPPORT_COLOR:
if any(mode in color_modes for mode in light.COLOR_MODES_COLOR):
response["colorModel"] = "hsv"
if features & light.SUPPORT_COLOR_TEMP:
if light.COLOR_MODE_COLOR_TEMP in color_modes:
# Max Kelvin is Min Mireds K = 1000000 / mireds
# Min Kelvin is Max Mireds K = 1000000 / mireds
response["colorTemperatureRange"] = {
@ -394,10 +398,10 @@ class ColorSettingTrait(_Trait):
def query_attributes(self):
"""Return color temperature query attributes."""
features = self.state.attributes.get(ATTR_SUPPORTED_FEATURES, 0)
color_modes = self.state.attributes.get(light.ATTR_SUPPORTED_COLOR_MODES, [])
color = {}
if features & light.SUPPORT_COLOR:
if any(mode in color_modes for mode in light.COLOR_MODES_COLOR):
color_hs = self.state.attributes.get(light.ATTR_HS_COLOR)
brightness = self.state.attributes.get(light.ATTR_BRIGHTNESS, 1)
if color_hs is not None:
@ -407,7 +411,7 @@ class ColorSettingTrait(_Trait):
"value": brightness / 255,
}
if features & light.SUPPORT_COLOR_TEMP:
if light.COLOR_MODE_COLOR_TEMP in color_modes:
temp = self.state.attributes.get(light.ATTR_COLOR_TEMP)
# Some faulty integrations might put 0 in here, raising exception.
if temp == 0:
@ -495,7 +499,7 @@ class SceneTrait(_Trait):
commands = [COMMAND_ACTIVATE_SCENE]
@staticmethod
def supported(domain, features, device_class):
def supported(domain, features, device_class, _):
"""Test if state is supported."""
return domain in (scene.DOMAIN, script.DOMAIN)
@ -531,7 +535,7 @@ class DockTrait(_Trait):
commands = [COMMAND_DOCK]
@staticmethod
def supported(domain, features, device_class):
def supported(domain, features, device_class, _):
"""Test if state is supported."""
return domain == vacuum.DOMAIN
@ -565,7 +569,7 @@ class StartStopTrait(_Trait):
commands = [COMMAND_STARTSTOP, COMMAND_PAUSEUNPAUSE]
@staticmethod
def supported(domain, features, device_class):
def supported(domain, features, device_class, _):
"""Test if state is supported."""
if domain == vacuum.DOMAIN:
return True
@ -709,7 +713,7 @@ class TemperatureSettingTrait(_Trait):
google_to_preset = {value: key for key, value in preset_to_google.items()}
@staticmethod
def supported(domain, features, device_class):
def supported(domain, features, device_class, _):
"""Test if state is supported."""
if domain == climate.DOMAIN:
return True
@ -976,7 +980,7 @@ class HumiditySettingTrait(_Trait):
commands = [COMMAND_SET_HUMIDITY]
@staticmethod
def supported(domain, features, device_class):
def supported(domain, features, device_class, _):
"""Test if state is supported."""
if domain == humidifier.DOMAIN:
return True
@ -1059,7 +1063,7 @@ class LockUnlockTrait(_Trait):
commands = [COMMAND_LOCKUNLOCK]
@staticmethod
def supported(domain, features, device_class):
def supported(domain, features, device_class, _):
"""Test if state is supported."""
return domain == lock.DOMAIN
@ -1120,7 +1124,7 @@ class ArmDisArmTrait(_Trait):
}
@staticmethod
def supported(domain, features, device_class):
def supported(domain, features, device_class, _):
"""Test if state is supported."""
return domain == alarm_control_panel.DOMAIN
@ -1236,7 +1240,7 @@ class FanSpeedTrait(_Trait):
}
@staticmethod
def supported(domain, features, device_class):
def supported(domain, features, device_class, _):
"""Test if state is supported."""
if domain == fan.DOMAIN:
return features & fan.SUPPORT_SET_SPEED
@ -1349,7 +1353,7 @@ class ModesTrait(_Trait):
}
@staticmethod
def supported(domain, features, device_class):
def supported(domain, features, device_class, _):
"""Test if state is supported."""
if domain == input_select.DOMAIN:
return True
@ -1518,7 +1522,7 @@ class InputSelectorTrait(_Trait):
SYNONYMS = {}
@staticmethod
def supported(domain, features, device_class):
def supported(domain, features, device_class, _):
"""Test if state is supported."""
if domain == media_player.DOMAIN and (
features & media_player.SUPPORT_SELECT_SOURCE
@ -1591,7 +1595,7 @@ class OpenCloseTrait(_Trait):
commands = [COMMAND_OPENCLOSE, COMMAND_OPENCLOSE_RELATIVE]
@staticmethod
def supported(domain, features, device_class):
def supported(domain, features, device_class, _):
"""Test if state is supported."""
if domain == cover.DOMAIN:
return True
@ -1727,7 +1731,7 @@ class VolumeTrait(_Trait):
commands = [COMMAND_SET_VOLUME, COMMAND_VOLUME_RELATIVE, COMMAND_MUTE]
@staticmethod
def supported(domain, features, device_class):
def supported(domain, features, device_class, _):
"""Test if trait is supported."""
if domain == media_player.DOMAIN:
return features & (
@ -1915,7 +1919,7 @@ class TransportControlTrait(_Trait):
]
@staticmethod
def supported(domain, features, device_class):
def supported(domain, features, device_class, _):
"""Test if state is supported."""
if domain == media_player.DOMAIN:
for feature in MEDIA_COMMAND_SUPPORT_MAPPING.values():
@ -2034,7 +2038,7 @@ class MediaStateTrait(_Trait):
}
@staticmethod
def supported(domain, features, device_class):
def supported(domain, features, device_class, _):
"""Test if state is supported."""
return domain == media_player.DOMAIN

6
tests/components/google_assistant/test_smart_home.py
View File

@ -1171,7 +1171,7 @@ async def test_sync_message_recovery(hass, caplog):
"on",
{
"min_mireds": "badvalue",
"supported_features": hass.components.light.SUPPORT_COLOR_TEMP,
"supported_color_modes": ["color_temp"],
},
)
@ -1220,7 +1220,7 @@ async def test_query_recover(hass, caplog):
"light.good",
"on",
{
"supported_features": hass.components.light.SUPPORT_BRIGHTNESS,
"supported_color_modes": ["brightness"],
"brightness": 50,
},
)
@ -1228,7 +1228,7 @@ async def test_query_recover(hass, caplog):
"light.bad",
"on",
{
"supported_features": hass.components.light.SUPPORT_BRIGHTNESS,
"supported_color_modes": ["brightness"],
"brightness": "shoe",
},
)

131
tests/components/google_assistant/test_trait.py
View File

@ -70,10 +70,15 @@ PIN_DATA = helpers.RequestData(
)
async def test_brightness_light(hass):
@pytest.mark.parametrize(
"supported_color_modes", [["brightness"], ["hs"], ["color_temp"]]
)
async def test_brightness_light(hass, supported_color_modes):
"""Test brightness trait support for light domain."""
assert helpers.get_google_type(light.DOMAIN, None) is not None
assert trait.BrightnessTrait.supported(light.DOMAIN, light.SUPPORT_BRIGHTNESS, None)
assert trait.BrightnessTrait.supported(
light.DOMAIN, 0, None, {"supported_color_modes": supported_color_modes}
)
trt = trait.BrightnessTrait(
hass,
@ -111,7 +116,9 @@ async def test_camera_stream(hass):
{"external_url": "https://example.com"},
)
assert helpers.get_google_type(camera.DOMAIN, None) is not None
assert trait.CameraStreamTrait.supported(camera.DOMAIN, camera.SUPPORT_STREAM, None)
assert trait.CameraStreamTrait.supported(
camera.DOMAIN, camera.SUPPORT_STREAM, None, None
)
trt = trait.CameraStreamTrait(
hass, State("camera.bla", camera.STATE_IDLE, {}), BASIC_CONFIG
@ -140,7 +147,7 @@ async def test_camera_stream(hass):
async def test_onoff_group(hass):
"""Test OnOff trait support for group domain."""
assert helpers.get_google_type(group.DOMAIN, None) is not None
assert trait.OnOffTrait.supported(group.DOMAIN, 0, None)
assert trait.OnOffTrait.supported(group.DOMAIN, 0, None, None)
trt_on = trait.OnOffTrait(hass, State("group.bla", STATE_ON), BASIC_CONFIG)
@ -166,7 +173,7 @@ async def test_onoff_group(hass):
async def test_onoff_input_boolean(hass):
"""Test OnOff trait support for input_boolean domain."""
assert helpers.get_google_type(input_boolean.DOMAIN, None) is not None
assert trait.OnOffTrait.supported(input_boolean.DOMAIN, 0, None)
assert trait.OnOffTrait.supported(input_boolean.DOMAIN, 0, None, None)
trt_on = trait.OnOffTrait(hass, State("input_boolean.bla", STATE_ON), BASIC_CONFIG)
@ -194,7 +201,7 @@ async def test_onoff_input_boolean(hass):
async def test_onoff_switch(hass):
"""Test OnOff trait support for switch domain."""
assert helpers.get_google_type(switch.DOMAIN, None) is not None
assert trait.OnOffTrait.supported(switch.DOMAIN, 0, None)
assert trait.OnOffTrait.supported(switch.DOMAIN, 0, None, None)
trt_on = trait.OnOffTrait(hass, State("switch.bla", STATE_ON), BASIC_CONFIG)
@ -225,7 +232,7 @@ async def test_onoff_switch(hass):
async def test_onoff_fan(hass):
"""Test OnOff trait support for fan domain."""
assert helpers.get_google_type(fan.DOMAIN, None) is not None
assert trait.OnOffTrait.supported(fan.DOMAIN, 0, None)
assert trait.OnOffTrait.supported(fan.DOMAIN, 0, None, None)
trt_on = trait.OnOffTrait(hass, State("fan.bla", STATE_ON), BASIC_CONFIG)
@ -250,7 +257,7 @@ async def test_onoff_fan(hass):
async def test_onoff_light(hass):
"""Test OnOff trait support for light domain."""
assert helpers.get_google_type(light.DOMAIN, None) is not None
assert trait.OnOffTrait.supported(light.DOMAIN, 0, None)
assert trait.OnOffTrait.supported(light.DOMAIN, 0, None, None)
trt_on = trait.OnOffTrait(hass, State("light.bla", STATE_ON), BASIC_CONFIG)
@ -276,7 +283,7 @@ async def test_onoff_light(hass):
async def test_onoff_media_player(hass):
"""Test OnOff trait support for media_player domain."""
assert helpers.get_google_type(media_player.DOMAIN, None) is not None
assert trait.OnOffTrait.supported(media_player.DOMAIN, 0, None)
assert trait.OnOffTrait.supported(media_player.DOMAIN, 0, None, None)
trt_on = trait.OnOffTrait(hass, State("media_player.bla", STATE_ON), BASIC_CONFIG)
@ -303,7 +310,7 @@ async def test_onoff_media_player(hass):
async def test_onoff_humidifier(hass):
"""Test OnOff trait support for humidifier domain."""
assert helpers.get_google_type(humidifier.DOMAIN, None) is not None
assert trait.OnOffTrait.supported(humidifier.DOMAIN, 0, None)
assert trait.OnOffTrait.supported(humidifier.DOMAIN, 0, None, None)
trt_on = trait.OnOffTrait(hass, State("humidifier.bla", STATE_ON), BASIC_CONFIG)
@ -330,7 +337,7 @@ async def test_onoff_humidifier(hass):
async def test_dock_vacuum(hass):
"""Test dock trait support for vacuum domain."""
assert helpers.get_google_type(vacuum.DOMAIN, None) is not None
assert trait.DockTrait.supported(vacuum.DOMAIN, 0, None)
assert trait.DockTrait.supported(vacuum.DOMAIN, 0, None, None)
trt = trait.DockTrait(hass, State("vacuum.bla", vacuum.STATE_IDLE), BASIC_CONFIG)
@ -347,7 +354,7 @@ async def test_dock_vacuum(hass):
async def test_startstop_vacuum(hass):
"""Test startStop trait support for vacuum domain."""
assert helpers.get_google_type(vacuum.DOMAIN, None) is not None
assert trait.StartStopTrait.supported(vacuum.DOMAIN, 0, None)
assert trait.StartStopTrait.supported(vacuum.DOMAIN, 0, None, None)
trt = trait.StartStopTrait(
hass,
@ -387,7 +394,7 @@ async def test_startstop_vacuum(hass):
async def test_startstop_cover(hass):
"""Test startStop trait support for cover domain."""
assert helpers.get_google_type(cover.DOMAIN, None) is not None
assert trait.StartStopTrait.supported(cover.DOMAIN, cover.SUPPORT_STOP, None)
assert trait.StartStopTrait.supported(cover.DOMAIN, cover.SUPPORT_STOP, None, None)
state = State(
"cover.bla",
@ -447,11 +454,14 @@ async def test_startstop_cover_assumed(hass):
assert stop_calls[0].data == {ATTR_ENTITY_ID: "cover.bla"}
async def test_color_setting_color_light(hass):
@pytest.mark.parametrize("supported_color_modes", [["hs"], ["rgb"], ["xy"]])
async def test_color_setting_color_light(hass, supported_color_modes):
"""Test ColorSpectrum trait support for light domain."""
assert helpers.get_google_type(light.DOMAIN, None) is not None
assert not trait.ColorSettingTrait.supported(light.DOMAIN, 0, None)
assert trait.ColorSettingTrait.supported(light.DOMAIN, light.SUPPORT_COLOR, None)
assert not trait.ColorSettingTrait.supported(light.DOMAIN, 0, None, {})
assert trait.ColorSettingTrait.supported(
light.DOMAIN, 0, None, {"supported_color_modes": supported_color_modes}
)
trt = trait.ColorSettingTrait(
hass,
@ -461,7 +471,7 @@ async def test_color_setting_color_light(hass):
{
light.ATTR_HS_COLOR: (20, 94),
light.ATTR_BRIGHTNESS: 200,
ATTR_SUPPORTED_FEATURES: light.SUPPORT_COLOR,
"supported_color_modes": supported_color_modes,
},
),
BASIC_CONFIG,
@ -507,9 +517,9 @@ async def test_color_setting_color_light(hass):
async def test_color_setting_temperature_light(hass):
"""Test ColorTemperature trait support for light domain."""
assert helpers.get_google_type(light.DOMAIN, None) is not None
assert not trait.ColorSettingTrait.supported(light.DOMAIN, 0, None)
assert not trait.ColorSettingTrait.supported(light.DOMAIN, 0, None, {})
assert trait.ColorSettingTrait.supported(
light.DOMAIN, light.SUPPORT_COLOR_TEMP, None
light.DOMAIN, 0, None, {"supported_color_modes": ["color_temp"]}
)
trt = trait.ColorSettingTrait(
@ -521,7 +531,7 @@ async def test_color_setting_temperature_light(hass):
light.ATTR_MIN_MIREDS: 200,
light.ATTR_COLOR_TEMP: 300,
light.ATTR_MAX_MIREDS: 500,
ATTR_SUPPORTED_FEATURES: light.SUPPORT_COLOR_TEMP,
"supported_color_modes": ["color_temp"],
},
),
BASIC_CONFIG,
@ -560,9 +570,9 @@ async def test_color_setting_temperature_light(hass):
async def test_color_light_temperature_light_bad_temp(hass):
"""Test ColorTemperature trait support for light domain."""
assert helpers.get_google_type(light.DOMAIN, None) is not None
assert not trait.ColorSettingTrait.supported(light.DOMAIN, 0, None)
assert not trait.ColorSettingTrait.supported(light.DOMAIN, 0, None, {})
assert trait.ColorSettingTrait.supported(
light.DOMAIN, light.SUPPORT_COLOR_TEMP, None
light.DOMAIN, 0, None, {"supported_color_modes": ["color_temp"]}
)
trt = trait.ColorSettingTrait(
@ -585,7 +595,7 @@ async def test_color_light_temperature_light_bad_temp(hass):
async def test_light_modes(hass):
"""Test Light Mode trait."""
assert helpers.get_google_type(light.DOMAIN, None) is not None
assert trait.ModesTrait.supported(light.DOMAIN, light.SUPPORT_EFFECT, None)
assert trait.ModesTrait.supported(light.DOMAIN, light.SUPPORT_EFFECT, None, None)
trt = trait.ModesTrait(
hass,
@ -653,7 +663,7 @@ async def test_light_modes(hass):
async def test_scene_scene(hass):
"""Test Scene trait support for scene domain."""
assert helpers.get_google_type(scene.DOMAIN, None) is not None
assert trait.SceneTrait.supported(scene.DOMAIN, 0, None)
assert trait.SceneTrait.supported(scene.DOMAIN, 0, None, None)
trt = trait.SceneTrait(hass, State("scene.bla", scene.STATE), BASIC_CONFIG)
assert trt.sync_attributes() == {}
@ -669,7 +679,7 @@ async def test_scene_scene(hass):
async def test_scene_script(hass):
"""Test Scene trait support for script domain."""
assert helpers.get_google_type(script.DOMAIN, None) is not None
assert trait.SceneTrait.supported(script.DOMAIN, 0, None)
assert trait.SceneTrait.supported(script.DOMAIN, 0, None, None)
trt = trait.SceneTrait(hass, State("script.bla", STATE_OFF), BASIC_CONFIG)
assert trt.sync_attributes() == {}
@ -689,7 +699,7 @@ async def test_scene_script(hass):
async def test_temperature_setting_climate_onoff(hass):
"""Test TemperatureSetting trait support for climate domain - range."""
assert helpers.get_google_type(climate.DOMAIN, None) is not None
assert trait.TemperatureSettingTrait.supported(climate.DOMAIN, 0, None)
assert trait.TemperatureSettingTrait.supported(climate.DOMAIN, 0, None, None)
hass.config.units.temperature_unit = TEMP_FAHRENHEIT
@ -734,7 +744,7 @@ async def test_temperature_setting_climate_onoff(hass):
async def test_temperature_setting_climate_no_modes(hass):
"""Test TemperatureSetting trait support for climate domain not supporting any modes."""
assert helpers.get_google_type(climate.DOMAIN, None) is not None
assert trait.TemperatureSettingTrait.supported(climate.DOMAIN, 0, None)
assert trait.TemperatureSettingTrait.supported(climate.DOMAIN, 0, None, None)
hass.config.units.temperature_unit = TEMP_CELSIUS
@ -760,7 +770,7 @@ async def test_temperature_setting_climate_no_modes(hass):
async def test_temperature_setting_climate_range(hass):
"""Test TemperatureSetting trait support for climate domain - range."""
assert helpers.get_google_type(climate.DOMAIN, None) is not None
assert trait.TemperatureSettingTrait.supported(climate.DOMAIN, 0, None)
assert trait.TemperatureSettingTrait.supported(climate.DOMAIN, 0, None, None)
hass.config.units.temperature_unit = TEMP_FAHRENHEIT
@ -842,7 +852,7 @@ async def test_temperature_setting_climate_range(hass):
async def test_temperature_setting_climate_setpoint(hass):
"""Test TemperatureSetting trait support for climate domain - setpoint."""
assert helpers.get_google_type(climate.DOMAIN, None) is not None
assert trait.TemperatureSettingTrait.supported(climate.DOMAIN, 0, None)
assert trait.TemperatureSettingTrait.supported(climate.DOMAIN, 0, None, None)
hass.config.units.temperature_unit = TEMP_CELSIUS
@ -947,7 +957,7 @@ async def test_temperature_setting_climate_setpoint_auto(hass):
async def test_humidity_setting_humidifier_setpoint(hass):
"""Test HumiditySetting trait support for humidifier domain - setpoint."""
assert helpers.get_google_type(humidifier.DOMAIN, None) is not None
assert trait.HumiditySettingTrait.supported(humidifier.DOMAIN, 0, None)
assert trait.HumiditySettingTrait.supported(humidifier.DOMAIN, 0, None, None)
trt = trait.HumiditySettingTrait(
hass,
@ -983,7 +993,7 @@ async def test_humidity_setting_humidifier_setpoint(hass):
async def test_lock_unlock_lock(hass):
"""Test LockUnlock trait locking support for lock domain."""
assert helpers.get_google_type(lock.DOMAIN, None) is not None
assert trait.LockUnlockTrait.supported(lock.DOMAIN, lock.SUPPORT_OPEN, None)
assert trait.LockUnlockTrait.supported(lock.DOMAIN, lock.SUPPORT_OPEN, None, None)
assert trait.LockUnlockTrait.might_2fa(lock.DOMAIN, lock.SUPPORT_OPEN, None)
trt = trait.LockUnlockTrait(
@ -1007,7 +1017,7 @@ async def test_lock_unlock_lock(hass):
async def test_lock_unlock_unlock(hass):
"""Test LockUnlock trait unlocking support for lock domain."""
assert helpers.get_google_type(lock.DOMAIN, None) is not None
assert trait.LockUnlockTrait.supported(lock.DOMAIN, lock.SUPPORT_OPEN, None)
assert trait.LockUnlockTrait.supported(lock.DOMAIN, lock.SUPPORT_OPEN, None, None)
trt = trait.LockUnlockTrait(
hass, State("lock.front_door", lock.STATE_LOCKED), PIN_CONFIG
@ -1067,7 +1077,7 @@ async def test_lock_unlock_unlock(hass):
async def test_arm_disarm_arm_away(hass):
"""Test ArmDisarm trait Arming support for alarm_control_panel domain."""
assert helpers.get_google_type(alarm_control_panel.DOMAIN, None) is not None
assert trait.ArmDisArmTrait.supported(alarm_control_panel.DOMAIN, 0, None)
assert trait.ArmDisArmTrait.supported(alarm_control_panel.DOMAIN, 0, None, None)
assert trait.ArmDisArmTrait.might_2fa(alarm_control_panel.DOMAIN, 0, None)
trt = trait.ArmDisArmTrait(
@ -1230,7 +1240,7 @@ async def test_arm_disarm_arm_away(hass):
async def test_arm_disarm_disarm(hass):
"""Test ArmDisarm trait Disarming support for alarm_control_panel domain."""
assert helpers.get_google_type(alarm_control_panel.DOMAIN, None) is not None
assert trait.ArmDisArmTrait.supported(alarm_control_panel.DOMAIN, 0, None)
assert trait.ArmDisArmTrait.supported(alarm_control_panel.DOMAIN, 0, None, None)
assert trait.ArmDisArmTrait.might_2fa(alarm_control_panel.DOMAIN, 0, None)
trt = trait.ArmDisArmTrait(
@ -1376,7 +1386,7 @@ async def test_arm_disarm_disarm(hass):
async def test_fan_speed(hass):
"""Test FanSpeed trait speed control support for fan domain."""
assert helpers.get_google_type(fan.DOMAIN, None) is not None
assert trait.FanSpeedTrait.supported(fan.DOMAIN, fan.SUPPORT_SET_SPEED, None)
assert trait.FanSpeedTrait.supported(fan.DOMAIN, fan.SUPPORT_SET_SPEED, None, None)
trt = trait.FanSpeedTrait(
hass,
@ -1468,7 +1478,9 @@ async def test_fan_speed(hass):
async def test_climate_fan_speed(hass):
"""Test FanSpeed trait speed control support for climate domain."""
assert helpers.get_google_type(climate.DOMAIN, None) is not None
assert trait.FanSpeedTrait.supported(climate.DOMAIN, climate.SUPPORT_FAN_MODE, None)
assert trait.FanSpeedTrait.supported(
climate.DOMAIN, climate.SUPPORT_FAN_MODE, None, None
)
trt = trait.FanSpeedTrait(
hass,
@ -1529,7 +1541,7 @@ async def test_inputselector(hass):
"""Test input selector trait."""
assert helpers.get_google_type(media_player.DOMAIN, None) is not None
assert trait.InputSelectorTrait.supported(
media_player.DOMAIN, media_player.SUPPORT_SELECT_SOURCE, None
media_player.DOMAIN, media_player.SUPPORT_SELECT_SOURCE, None, None
)
trt = trait.InputSelectorTrait(
@ -1686,7 +1698,7 @@ async def test_inputselector_nextprev_invalid(hass, sources, source):
async def test_modes_input_select(hass):
"""Test Input Select Mode trait."""
assert helpers.get_google_type(input_select.DOMAIN, None) is not None
assert trait.ModesTrait.supported(input_select.DOMAIN, None, None)
assert trait.ModesTrait.supported(input_select.DOMAIN, None, None, None)
trt = trait.ModesTrait(
hass,
@ -1762,7 +1774,9 @@ async def test_modes_input_select(hass):
async def test_modes_humidifier(hass):
"""Test Humidifier Mode trait."""
assert helpers.get_google_type(humidifier.DOMAIN, None) is not None
assert trait.ModesTrait.supported(humidifier.DOMAIN, humidifier.SUPPORT_MODES, None)
assert trait.ModesTrait.supported(
humidifier.DOMAIN, humidifier.SUPPORT_MODES, None, None
)
trt = trait.ModesTrait(
hass,
@ -1840,7 +1854,7 @@ async def test_sound_modes(hass):
"""Test Mode trait."""
assert helpers.get_google_type(media_player.DOMAIN, None) is not None
assert trait.ModesTrait.supported(
media_player.DOMAIN, media_player.SUPPORT_SELECT_SOUND_MODE, None
media_player.DOMAIN, media_player.SUPPORT_SELECT_SOUND_MODE, None, None
)
trt = trait.ModesTrait(
@ -1914,7 +1928,7 @@ async def test_openclose_cover(hass):
"""Test OpenClose trait support for cover domain."""
assert helpers.get_google_type(cover.DOMAIN, None) is not None
assert trait.OpenCloseTrait.supported(
cover.DOMAIN, cover.SUPPORT_SET_POSITION, None
cover.DOMAIN, cover.SUPPORT_SET_POSITION, None, None
)
trt = trait.OpenCloseTrait(
@ -1951,7 +1965,7 @@ async def test_openclose_cover_unknown_state(hass):
"""Test OpenClose trait support for cover domain with unknown state."""
assert helpers.get_google_type(cover.DOMAIN, None) is not None
assert trait.OpenCloseTrait.supported(
cover.DOMAIN, cover.SUPPORT_SET_POSITION, None
cover.DOMAIN, cover.SUPPORT_SET_POSITION, None, None
)
# No state
@ -1981,7 +1995,7 @@ async def test_openclose_cover_assumed_state(hass):
"""Test OpenClose trait support for cover domain."""
assert helpers.get_google_type(cover.DOMAIN, None) is not None
assert trait.OpenCloseTrait.supported(
cover.DOMAIN, cover.SUPPORT_SET_POSITION, None
cover.DOMAIN, cover.SUPPORT_SET_POSITION, None, None
)
trt = trait.OpenCloseTrait(
@ -2010,7 +2024,7 @@ async def test_openclose_cover_assumed_state(hass):
async def test_openclose_cover_query_only(hass):
"""Test OpenClose trait support for cover domain."""
assert helpers.get_google_type(cover.DOMAIN, None) is not None
assert trait.OpenCloseTrait.supported(cover.DOMAIN, 0, None)
assert trait.OpenCloseTrait.supported(cover.DOMAIN, 0, None, None)
state = State(
"cover.bla",
@ -2034,7 +2048,7 @@ async def test_openclose_cover_no_position(hass):
"""Test OpenClose trait support for cover domain."""
assert helpers.get_google_type(cover.DOMAIN, None) is not None
assert trait.OpenCloseTrait.supported(
cover.DOMAIN, cover.SUPPORT_OPEN | cover.SUPPORT_CLOSE, None
cover.DOMAIN, cover.SUPPORT_OPEN | cover.SUPPORT_CLOSE, None, None
)
state = State(
@ -2091,7 +2105,7 @@ async def test_openclose_cover_secure(hass, device_class):
"""Test OpenClose trait support for cover domain."""
assert helpers.get_google_type(cover.DOMAIN, device_class) is not None
assert trait.OpenCloseTrait.supported(
cover.DOMAIN, cover.SUPPORT_SET_POSITION, device_class
cover.DOMAIN, cover.SUPPORT_SET_POSITION, device_class, None
)
assert trait.OpenCloseTrait.might_2fa(
cover.DOMAIN, cover.SUPPORT_SET_POSITION, device_class
@ -2158,7 +2172,7 @@ async def test_openclose_cover_secure(hass, device_class):
async def test_openclose_binary_sensor(hass, device_class):
"""Test OpenClose trait support for binary_sensor domain."""
assert helpers.get_google_type(binary_sensor.DOMAIN, device_class) is not None
assert trait.OpenCloseTrait.supported(binary_sensor.DOMAIN, 0, device_class)
assert trait.OpenCloseTrait.supported(binary_sensor.DOMAIN, 0, device_class, None)
trt = trait.OpenCloseTrait(
hass,
@ -2191,9 +2205,7 @@ async def test_volume_media_player(hass):
"""Test volume trait support for media player domain."""
assert helpers.get_google_type(media_player.DOMAIN, None) is not None
assert trait.VolumeTrait.supported(
media_player.DOMAIN,
media_player.SUPPORT_VOLUME_SET,
None,
media_player.DOMAIN, media_player.SUPPORT_VOLUME_SET, None, None
)
trt = trait.VolumeTrait(
@ -2244,9 +2256,7 @@ async def test_volume_media_player(hass):
async def test_volume_media_player_relative(hass):
"""Test volume trait support for relative-volume-only media players."""
assert trait.VolumeTrait.supported(
media_player.DOMAIN,
media_player.SUPPORT_VOLUME_STEP,
None,
media_player.DOMAIN, media_player.SUPPORT_VOLUME_STEP, None, None
)
trt = trait.VolumeTrait(
hass,
@ -2314,6 +2324,7 @@ async def test_media_player_mute(hass):
media_player.DOMAIN,
media_player.SUPPORT_VOLUME_STEP | media_player.SUPPORT_VOLUME_MUTE,
None,
None,
)
trt = trait.VolumeTrait(
hass,
@ -2376,10 +2387,10 @@ async def test_temperature_setting_sensor(hass):
is not None
)
assert not trait.TemperatureSettingTrait.supported(
sensor.DOMAIN, 0, sensor.DEVICE_CLASS_HUMIDITY
sensor.DOMAIN, 0, sensor.DEVICE_CLASS_HUMIDITY, None
)
assert trait.TemperatureSettingTrait.supported(
sensor.DOMAIN, 0, sensor.DEVICE_CLASS_TEMPERATURE
sensor.DOMAIN, 0, sensor.DEVICE_CLASS_TEMPERATURE, None
)
@ -2422,10 +2433,10 @@ async def test_humidity_setting_sensor(hass):
helpers.get_google_type(sensor.DOMAIN, sensor.DEVICE_CLASS_HUMIDITY) is not None
)
assert not trait.HumiditySettingTrait.supported(
sensor.DOMAIN, 0, sensor.DEVICE_CLASS_TEMPERATURE
sensor.DOMAIN, 0, sensor.DEVICE_CLASS_TEMPERATURE, None
)
assert trait.HumiditySettingTrait.supported(
sensor.DOMAIN, 0, sensor.DEVICE_CLASS_HUMIDITY
sensor.DOMAIN, 0, sensor.DEVICE_CLASS_HUMIDITY, None
)
@ -2456,7 +2467,9 @@ async def test_transport_control(hass):
assert helpers.get_google_type(media_player.DOMAIN, None) is not None
for feature in trait.MEDIA_COMMAND_SUPPORT_MAPPING.values():
assert trait.TransportControlTrait.supported(media_player.DOMAIN, feature, None)
assert trait.TransportControlTrait.supported(
media_player.DOMAIN, feature, None, None
)
now = datetime(2020, 1, 1)
@ -2586,7 +2599,7 @@ async def test_media_state(hass, state):
assert helpers.get_google_type(media_player.DOMAIN, None) is not None
assert trait.TransportControlTrait.supported(
media_player.DOMAIN, media_player.SUPPORT_PLAY, None
media_player.DOMAIN, media_player.SUPPORT_PLAY, None, None
)
trt = trait.MediaStateTrait(