jeans/core
jeans/core
1
0
Fork 0
mirror of https://github.com/home-assistant/core.git synced 2025-04-28 19:27:51 +00:00
Code Issues Packages Projects Releases Wiki Activity

Reorder Google Assistant Traits (#127646)

Browse Source
This commit is contained in:
Joost Lekkerkerker 2024-10-16 15:04:46 +02:00 committed by GitHub
parent e5a07da0c9
commit c0f19dd963
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
3 changed files with 173 additions and 168 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -109,61 +109,42 @@ from .error import ChallengeNeeded, SmartHomeError
_LOGGER = logging.getLogger(__name__) _LOGGER = logging.getLogger(__name__)
PREFIX_TRAITS = "action.devices.traits." PREFIX_TRAITS = "action.devices.traits."
TRAIT_CAMERA_STREAM = f"{PREFIX_TRAITS}CameraStream" TRAIT_ARM_DISARM = f"{PREFIX_TRAITS}ArmDisarm"
TRAIT_ONOFF = f"{PREFIX_TRAITS}OnOff"
TRAIT_DOCK = f"{PREFIX_TRAITS}Dock"
TRAIT_STARTSTOP = f"{PREFIX_TRAITS}StartStop"
TRAIT_BRIGHTNESS = f"{PREFIX_TRAITS}Brightness" TRAIT_BRIGHTNESS = f"{PREFIX_TRAITS}Brightness"
TRAIT_COLOR_SETTING = f"{PREFIX_TRAITS}ColorSetting" TRAIT_CAMERA_STREAM = f"{PREFIX_TRAITS}CameraStream"
TRAIT_SCENE = f"{PREFIX_TRAITS}Scene"
TRAIT_TEMPERATURE_SETTING = f"{PREFIX_TRAITS}TemperatureSetting"
TRAIT_TEMPERATURE_CONTROL = f"{PREFIX_TRAITS}TemperatureControl"
TRAIT_LOCKUNLOCK = f"{PREFIX_TRAITS}LockUnlock"
TRAIT_FANSPEED = f"{PREFIX_TRAITS}FanSpeed"
TRAIT_MODES = f"{PREFIX_TRAITS}Modes"
TRAIT_INPUTSELECTOR = f"{PREFIX_TRAITS}InputSelector"
TRAIT_OBJECTDETECTION = f"{PREFIX_TRAITS}ObjectDetection"
TRAIT_OPENCLOSE = f"{PREFIX_TRAITS}OpenClose"
TRAIT_VOLUME = f"{PREFIX_TRAITS}Volume"
TRAIT_ARMDISARM = f"{PREFIX_TRAITS}ArmDisarm"
TRAIT_HUMIDITY_SETTING = f"{PREFIX_TRAITS}HumiditySetting"
TRAIT_TRANSPORT_CONTROL = f"{PREFIX_TRAITS}TransportControl"
TRAIT_MEDIA_STATE = f"{PREFIX_TRAITS}MediaState"
TRAIT_CHANNEL = f"{PREFIX_TRAITS}Channel" TRAIT_CHANNEL = f"{PREFIX_TRAITS}Channel"
TRAIT_COLOR_SETTING = f"{PREFIX_TRAITS}ColorSetting"
TRAIT_DOCK = f"{PREFIX_TRAITS}Dock"
TRAIT_ENERGY_STORAGE = f"{PREFIX_TRAITS}EnergyStorage"
TRAIT_FAN_SPEED = f"{PREFIX_TRAITS}FanSpeed"
TRAIT_HUMIDITY_SETTING = f"{PREFIX_TRAITS}HumiditySetting"
TRAIT_INPUT_SELECTOR = f"{PREFIX_TRAITS}InputSelector"
TRAIT_LOCATOR = f"{PREFIX_TRAITS}Locator" TRAIT_LOCATOR = f"{PREFIX_TRAITS}Locator"
TRAIT_ENERGYSTORAGE = f"{PREFIX_TRAITS}EnergyStorage" TRAIT_LOCK_UNLOCK = f"{PREFIX_TRAITS}LockUnlock"
TRAIT_MEDIA_STATE = f"{PREFIX_TRAITS}MediaState"
TRAIT_MODES = f"{PREFIX_TRAITS}Modes"
TRAIT_OBJECT_DETECTION = f"{PREFIX_TRAITS}ObjectDetection"
TRAIT_ON_OFF = f"{PREFIX_TRAITS}OnOff"
TRAIT_OPEN_CLOSE = f"{PREFIX_TRAITS}OpenClose"
TRAIT_SCENE = f"{PREFIX_TRAITS}Scene"
TRAIT_SENSOR_STATE = f"{PREFIX_TRAITS}SensorState" TRAIT_SENSOR_STATE = f"{PREFIX_TRAITS}SensorState"
TRAIT_START_STOP = f"{PREFIX_TRAITS}StartStop"
TRAIT_TEMPERATURE_CONTROL = f"{PREFIX_TRAITS}TemperatureControl"
TRAIT_TEMPERATURE_SETTING = f"{PREFIX_TRAITS}TemperatureSetting"
TRAIT_TRANSPORT_CONTROL = f"{PREFIX_TRAITS}TransportControl"
TRAIT_VOLUME = f"{PREFIX_TRAITS}Volume"
PREFIX_COMMANDS = "action.devices.commands." PREFIX_COMMANDS = "action.devices.commands."
COMMAND_ONOFF = f"{PREFIX_COMMANDS}OnOff"
COMMAND_GET_CAMERA_STREAM = f"{PREFIX_COMMANDS}GetCameraStream"
COMMAND_DOCK = f"{PREFIX_COMMANDS}Dock"
COMMAND_STARTSTOP = f"{PREFIX_COMMANDS}StartStop"
COMMAND_PAUSEUNPAUSE = f"{PREFIX_COMMANDS}PauseUnpause"
COMMAND_BRIGHTNESS_ABSOLUTE = f"{PREFIX_COMMANDS}BrightnessAbsolute"
COMMAND_COLOR_ABSOLUTE = f"{PREFIX_COMMANDS}ColorAbsolute"
COMMAND_ACTIVATE_SCENE = f"{PREFIX_COMMANDS}ActivateScene" COMMAND_ACTIVATE_SCENE = f"{PREFIX_COMMANDS}ActivateScene"
COMMAND_SET_TEMPERATURE = f"{PREFIX_COMMANDS}SetTemperature" COMMAND_ARM_DISARM = f"{PREFIX_COMMANDS}ArmDisarm"
COMMAND_THERMOSTAT_TEMPERATURE_SETPOINT = ( COMMAND_BRIGHTNESS_ABSOLUTE = f"{PREFIX_COMMANDS}BrightnessAbsolute"
f"{PREFIX_COMMANDS}ThermostatTemperatureSetpoint" COMMAND_CHARGE = f"{PREFIX_COMMANDS}Charge"
) COMMAND_COLOR_ABSOLUTE = f"{PREFIX_COMMANDS}ColorAbsolute"
COMMAND_THERMOSTAT_TEMPERATURE_SET_RANGE = ( COMMAND_DOCK = f"{PREFIX_COMMANDS}Dock"
f"{PREFIX_COMMANDS}ThermostatTemperatureSetRange" COMMAND_GET_CAMERA_STREAM = f"{PREFIX_COMMANDS}GetCameraStream"
) COMMAND_LOCK_UNLOCK = f"{PREFIX_COMMANDS}LockUnlock"
COMMAND_THERMOSTAT_SET_MODE = f"{PREFIX_COMMANDS}ThermostatSetMode" COMMAND_LOCATE = f"{PREFIX_COMMANDS}Locate"
COMMAND_LOCKUNLOCK = f"{PREFIX_COMMANDS}LockUnlock"
COMMAND_FANSPEED = f"{PREFIX_COMMANDS}SetFanSpeed"
COMMAND_FANSPEEDRELATIVE = f"{PREFIX_COMMANDS}SetFanSpeedRelative"
COMMAND_MODES = f"{PREFIX_COMMANDS}SetModes"
COMMAND_INPUT = f"{PREFIX_COMMANDS}SetInput"
COMMAND_NEXT_INPUT = f"{PREFIX_COMMANDS}NextInput" COMMAND_NEXT_INPUT = f"{PREFIX_COMMANDS}NextInput"
COMMAND_PREVIOUS_INPUT = f"{PREFIX_COMMANDS}PreviousInput"
COMMAND_OPENCLOSE = f"{PREFIX_COMMANDS}OpenClose"
COMMAND_OPENCLOSE_RELATIVE = f"{PREFIX_COMMANDS}OpenCloseRelative"
COMMAND_SET_VOLUME = f"{PREFIX_COMMANDS}setVolume"
COMMAND_VOLUME_RELATIVE = f"{PREFIX_COMMANDS}volumeRelative"
COMMAND_MUTE = f"{PREFIX_COMMANDS}mute"
COMMAND_ARMDISARM = f"{PREFIX_COMMANDS}ArmDisarm"
COMMAND_MEDIA_NEXT = f"{PREFIX_COMMANDS}mediaNext" COMMAND_MEDIA_NEXT = f"{PREFIX_COMMANDS}mediaNext"
COMMAND_MEDIA_PAUSE = f"{PREFIX_COMMANDS}mediaPause" COMMAND_MEDIA_PAUSE = f"{PREFIX_COMMANDS}mediaPause"
COMMAND_MEDIA_PREVIOUS = f"{PREFIX_COMMANDS}mediaPrevious" COMMAND_MEDIA_PREVIOUS = f"{PREFIX_COMMANDS}mediaPrevious"
@ -172,11 +153,30 @@ COMMAND_MEDIA_SEEK_RELATIVE = f"{PREFIX_COMMANDS}mediaSeekRelative"
COMMAND_MEDIA_SEEK_TO_POSITION = f"{PREFIX_COMMANDS}mediaSeekToPosition" COMMAND_MEDIA_SEEK_TO_POSITION = f"{PREFIX_COMMANDS}mediaSeekToPosition"
COMMAND_MEDIA_SHUFFLE = f"{PREFIX_COMMANDS}mediaShuffle" COMMAND_MEDIA_SHUFFLE = f"{PREFIX_COMMANDS}mediaShuffle"
COMMAND_MEDIA_STOP = f"{PREFIX_COMMANDS}mediaStop" COMMAND_MEDIA_STOP = f"{PREFIX_COMMANDS}mediaStop"
COMMAND_MUTE = f"{PREFIX_COMMANDS}mute"
COMMAND_OPEN_CLOSE = f"{PREFIX_COMMANDS}OpenClose"
COMMAND_ON_OFF = f"{PREFIX_COMMANDS}OnOff"
COMMAND_OPEN_CLOSE_RELATIVE = f"{PREFIX_COMMANDS}OpenCloseRelative"
COMMAND_PAUSE_UNPAUSE = f"{PREFIX_COMMANDS}PauseUnpause"
COMMAND_REVERSE = f"{PREFIX_COMMANDS}Reverse" COMMAND_REVERSE = f"{PREFIX_COMMANDS}Reverse"
COMMAND_SET_HUMIDITY = f"{PREFIX_COMMANDS}SetHumidity" COMMAND_PREVIOUS_INPUT = f"{PREFIX_COMMANDS}PreviousInput"
COMMAND_SELECT_CHANNEL = f"{PREFIX_COMMANDS}selectChannel" COMMAND_SELECT_CHANNEL = f"{PREFIX_COMMANDS}selectChannel"
COMMAND_LOCATE = f"{PREFIX_COMMANDS}Locate" COMMAND_SET_TEMPERATURE = f"{PREFIX_COMMANDS}SetTemperature"
COMMAND_CHARGE = f"{PREFIX_COMMANDS}Charge" COMMAND_SET_FAN_SPEED = f"{PREFIX_COMMANDS}SetFanSpeed"
COMMAND_SET_FAN_SPEED_RELATIVE = f"{PREFIX_COMMANDS}SetFanSpeedRelative"
COMMAND_SET_HUMIDITY = f"{PREFIX_COMMANDS}SetHumidity"
COMMAND_SET_INPUT = f"{PREFIX_COMMANDS}SetInput"
COMMAND_SET_MODES = f"{PREFIX_COMMANDS}SetModes"
COMMAND_SET_VOLUME = f"{PREFIX_COMMANDS}setVolume"
COMMAND_START_STOP = f"{PREFIX_COMMANDS}StartStop"
COMMAND_THERMOSTAT_SET_MODE = f"{PREFIX_COMMANDS}ThermostatSetMode"
COMMAND_THERMOSTAT_TEMPERATURE_SETPOINT = (
f"{PREFIX_COMMANDS}ThermostatTemperatureSetpoint"
)
COMMAND_THERMOSTAT_TEMPERATURE_SET_RANGE = (
f"{PREFIX_COMMANDS}ThermostatTemperatureSetRange"
)
COMMAND_VOLUME_RELATIVE = f"{PREFIX_COMMANDS}volumeRelative"
TRAITS: list[type[_Trait]] = [] TRAITS: list[type[_Trait]] = []
@ -415,7 +415,7 @@ class ObjectDetection(_Trait):
https://developers.google.com/actions/smarthome/traits/objectdetection https://developers.google.com/actions/smarthome/traits/objectdetection
""" """
name = TRAIT_OBJECTDETECTION name = TRAIT_OBJECT_DETECTION
commands = [] commands = []
@staticmethod @staticmethod
@ -473,8 +473,8 @@ class OnOffTrait(_Trait):
https://developers.google.com/actions/smarthome/traits/onoff https://developers.google.com/actions/smarthome/traits/onoff
""" """
name = TRAIT_ONOFF name = TRAIT_ON_OFF
commands = [COMMAND_ONOFF] commands = [COMMAND_ON_OFF]
@staticmethod @staticmethod
def supported(domain, features, device_class, _): def supported(domain, features, device_class, _):
@ -793,7 +793,7 @@ class EnergyStorageTrait(_Trait):
https://developers.google.com/actions/smarthome/traits/energystorage https://developers.google.com/actions/smarthome/traits/energystorage
""" """
name = TRAIT_ENERGYSTORAGE name = TRAIT_ENERGY_STORAGE
commands = [COMMAND_CHARGE] commands = [COMMAND_CHARGE]
@staticmethod @staticmethod
@ -848,8 +848,8 @@ class StartStopTrait(_Trait):
https://developers.google.com/actions/smarthome/traits/startstop https://developers.google.com/actions/smarthome/traits/startstop
""" """
name = TRAIT_STARTSTOP name = TRAIT_START_STOP
commands = [COMMAND_STARTSTOP, COMMAND_PAUSEUNPAUSE] commands = [COMMAND_START_STOP, COMMAND_PAUSE_UNPAUSE]
@staticmethod @staticmethod
def supported(domain, features, device_class, _): def supported(domain, features, device_class, _):
@ -913,7 +913,7 @@ class StartStopTrait(_Trait):
async def _execute_vacuum(self, command, data, params, challenge): async def _execute_vacuum(self, command, data, params, challenge):
"""Execute a StartStop command.""" """Execute a StartStop command."""
if command == COMMAND_STARTSTOP: if command == COMMAND_START_STOP:
if params["start"]: if params["start"]:
await self.hass.services.async_call( await self.hass.services.async_call(
self.state.domain, self.state.domain,
@ -930,7 +930,7 @@ class StartStopTrait(_Trait):
blocking=not self.config.should_report_state, blocking=not self.config.should_report_state,
context=data.context, context=data.context,
) )
elif command == COMMAND_PAUSEUNPAUSE: elif command == COMMAND_PAUSE_UNPAUSE:
if params["pause"]: if params["pause"]:
await self.hass.services.async_call( await self.hass.services.async_call(
self.state.domain, self.state.domain,
@ -951,7 +951,7 @@ class StartStopTrait(_Trait):
async def _execute_cover_or_valve(self, command, data, params, challenge): async def _execute_cover_or_valve(self, command, data, params, challenge):
"""Execute a StartStop command.""" """Execute a StartStop command."""
domain = self.state.domain domain = self.state.domain
if command == COMMAND_STARTSTOP: if command == COMMAND_START_STOP:
if params["start"] is False: if params["start"] is False:
if self.state.state in ( if self.state.state in (
COVER_VALVE_STATES[domain]["closing"], COVER_VALVE_STATES[domain]["closing"],
@ -1504,8 +1504,8 @@ class LockUnlockTrait(_Trait):
https://developers.google.com/actions/smarthome/traits/lockunlock https://developers.google.com/actions/smarthome/traits/lockunlock
""" """
name = TRAIT_LOCKUNLOCK name = TRAIT_LOCK_UNLOCK
commands = [COMMAND_LOCKUNLOCK] commands = [COMMAND_LOCK_UNLOCK]
@staticmethod @staticmethod
def supported(domain, features, device_class, _): def supported(domain, features, device_class, _):
@ -1553,8 +1553,8 @@ class ArmDisArmTrait(_Trait):
https://developers.google.com/actions/smarthome/traits/armdisarm https://developers.google.com/actions/smarthome/traits/armdisarm
""" """
name = TRAIT_ARMDISARM name = TRAIT_ARM_DISARM
commands = [COMMAND_ARMDISARM] commands = [COMMAND_ARM_DISARM]
state_to_service = { state_to_service = {
STATE_ALARM_ARMED_HOME: SERVICE_ALARM_ARM_HOME, STATE_ALARM_ARMED_HOME: SERVICE_ALARM_ARM_HOME,
@ -1694,8 +1694,8 @@ class FanSpeedTrait(_Trait):
https://developers.google.com/actions/smarthome/traits/fanspeed https://developers.google.com/actions/smarthome/traits/fanspeed
""" """
name = TRAIT_FANSPEED name = TRAIT_FAN_SPEED
commands = [COMMAND_FANSPEED, COMMAND_REVERSE] commands = [COMMAND_SET_FAN_SPEED, COMMAND_REVERSE]
def __init__(self, hass, state, config): def __init__(self, hass, state, config):
"""Initialize a trait for a state.""" """Initialize a trait for a state."""
@ -1840,7 +1840,7 @@ class FanSpeedTrait(_Trait):
async def execute(self, command, data, params, challenge): async def execute(self, command, data, params, challenge):
"""Execute a smart home command.""" """Execute a smart home command."""
if command == COMMAND_FANSPEED: if command == COMMAND_SET_FAN_SPEED:
await self.execute_fanspeed(data, params) await self.execute_fanspeed(data, params)
elif command == COMMAND_REVERSE: elif command == COMMAND_REVERSE:
await self.execute_reverse(data, params) await self.execute_reverse(data, params)
@ -1854,7 +1854,7 @@ class ModesTrait(_Trait):
""" """
name = TRAIT_MODES name = TRAIT_MODES
commands = [COMMAND_MODES] commands = [COMMAND_SET_MODES]
SYNONYMS = { SYNONYMS = {
"preset mode": ["preset mode", "mode", "preset"], "preset mode": ["preset mode", "mode", "preset"],
@ -2088,8 +2088,8 @@ class InputSelectorTrait(_Trait):
https://developers.google.com/assistant/smarthome/traits/inputselector https://developers.google.com/assistant/smarthome/traits/inputselector
""" """
name = TRAIT_INPUTSELECTOR name = TRAIT_INPUT_SELECTOR
commands = [COMMAND_INPUT, COMMAND_NEXT_INPUT, COMMAND_PREVIOUS_INPUT] commands = [COMMAND_SET_INPUT, COMMAND_NEXT_INPUT, COMMAND_PREVIOUS_INPUT]
SYNONYMS: dict[str, list[str]] = {} SYNONYMS: dict[str, list[str]] = {}
@ -2124,7 +2124,7 @@ class InputSelectorTrait(_Trait):
sources = self.state.attributes.get(media_player.ATTR_INPUT_SOURCE_LIST) or [] sources = self.state.attributes.get(media_player.ATTR_INPUT_SOURCE_LIST) or []
source = self.state.attributes.get(media_player.ATTR_INPUT_SOURCE) source = self.state.attributes.get(media_player.ATTR_INPUT_SOURCE)
if command == COMMAND_INPUT: if command == COMMAND_SET_INPUT:
requested_source = params.get("newInput") requested_source = params.get("newInput")
elif command == COMMAND_NEXT_INPUT: elif command == COMMAND_NEXT_INPUT:
requested_source = _next_selected(sources, source) requested_source = _next_selected(sources, source)
@ -2162,8 +2162,8 @@ class OpenCloseTrait(_Trait):
cover.CoverDeviceClass.GATE, cover.CoverDeviceClass.GATE,
) )
name = TRAIT_OPENCLOSE name = TRAIT_OPEN_CLOSE
commands = [COMMAND_OPENCLOSE, COMMAND_OPENCLOSE_RELATIVE] commands = [COMMAND_OPEN_CLOSE, COMMAND_OPEN_CLOSE_RELATIVE]
@staticmethod @staticmethod
def supported(domain, features, device_class, _): def supported(domain, features, device_class, _):
@ -2263,7 +2263,7 @@ class OpenCloseTrait(_Trait):
if domain in COVER_VALVE_DOMAINS: if domain in COVER_VALVE_DOMAINS:
svc_params = {ATTR_ENTITY_ID: self.state.entity_id} svc_params = {ATTR_ENTITY_ID: self.state.entity_id}
should_verify = False should_verify = False
if command == COMMAND_OPENCLOSE_RELATIVE: if command == COMMAND_OPEN_CLOSE_RELATIVE:
position = self.state.attributes.get( position = self.state.attributes.get(
COVER_VALVE_CURRENT_POSITION[domain] COVER_VALVE_CURRENT_POSITION[domain]
) )

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

@ -209,7 +209,7 @@ async def test_sync_message(hass: HomeAssistant, registries) -> None:
}, },
"traits": [ "traits": [
trait.TRAIT_BRIGHTNESS, trait.TRAIT_BRIGHTNESS,
trait.TRAIT_ONOFF, trait.TRAIT_ON_OFF,
trait.TRAIT_COLOR_SETTING, trait.TRAIT_COLOR_SETTING,
trait.TRAIT_MODES, trait.TRAIT_MODES,
], ],
@ -329,7 +329,7 @@ async def test_sync_in_area(area_on_device, hass: HomeAssistant, registries) ->
"name": {"name": "Demo Light"}, "name": {"name": "Demo Light"},
"traits": [ "traits": [
trait.TRAIT_BRIGHTNESS, trait.TRAIT_BRIGHTNESS,
trait.TRAIT_ONOFF, trait.TRAIT_ON_OFF,
trait.TRAIT_COLOR_SETTING, trait.TRAIT_COLOR_SETTING,
trait.TRAIT_MODES, trait.TRAIT_MODES,
], ],
@ -926,7 +926,7 @@ async def test_unavailable_state_does_sync(hass: HomeAssistant) -> None:
"name": {"name": "Demo Light"}, "name": {"name": "Demo Light"},
"traits": [ "traits": [
trait.TRAIT_BRIGHTNESS, trait.TRAIT_BRIGHTNESS,
trait.TRAIT_ONOFF, trait.TRAIT_ON_OFF,
trait.TRAIT_COLOR_SETTING, trait.TRAIT_COLOR_SETTING,
trait.TRAIT_MODES, trait.TRAIT_MODES,
], ],

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

@ -187,12 +187,12 @@ async def test_onoff_group(hass: HomeAssistant) -> None:
assert trt_off.query_attributes() == {"on": False} assert trt_off.query_attributes() == {"on": False}
on_calls = async_mock_service(hass, HOMEASSISTANT_DOMAIN, SERVICE_TURN_ON) on_calls = async_mock_service(hass, HOMEASSISTANT_DOMAIN, SERVICE_TURN_ON)
await trt_on.execute(trait.COMMAND_ONOFF, BASIC_DATA, {"on": True}, {}) await trt_on.execute(trait.COMMAND_ON_OFF, BASIC_DATA, {"on": True}, {})
assert len(on_calls) == 1 assert len(on_calls) == 1
assert on_calls[0].data == {ATTR_ENTITY_ID: "group.bla"} assert on_calls[0].data == {ATTR_ENTITY_ID: "group.bla"}
off_calls = async_mock_service(hass, HOMEASSISTANT_DOMAIN, SERVICE_TURN_OFF) off_calls = async_mock_service(hass, HOMEASSISTANT_DOMAIN, SERVICE_TURN_OFF)
await trt_on.execute(trait.COMMAND_ONOFF, BASIC_DATA, {"on": False}, {}) await trt_on.execute(trait.COMMAND_ON_OFF, BASIC_DATA, {"on": False}, {})
assert len(off_calls) == 1 assert len(off_calls) == 1
assert off_calls[0].data == {ATTR_ENTITY_ID: "group.bla"} assert off_calls[0].data == {ATTR_ENTITY_ID: "group.bla"}
@ -215,12 +215,12 @@ async def test_onoff_input_boolean(hass: HomeAssistant) -> None:
assert trt_off.query_attributes() == {"on": False} assert trt_off.query_attributes() == {"on": False}
on_calls = async_mock_service(hass, input_boolean.DOMAIN, SERVICE_TURN_ON) on_calls = async_mock_service(hass, input_boolean.DOMAIN, SERVICE_TURN_ON)
await trt_on.execute(trait.COMMAND_ONOFF, BASIC_DATA, {"on": True}, {}) await trt_on.execute(trait.COMMAND_ON_OFF, BASIC_DATA, {"on": True}, {})
assert len(on_calls) == 1 assert len(on_calls) == 1
assert on_calls[0].data == {ATTR_ENTITY_ID: "input_boolean.bla"} assert on_calls[0].data == {ATTR_ENTITY_ID: "input_boolean.bla"}
off_calls = async_mock_service(hass, input_boolean.DOMAIN, SERVICE_TURN_OFF) off_calls = async_mock_service(hass, input_boolean.DOMAIN, SERVICE_TURN_OFF)
await trt_on.execute(trait.COMMAND_ONOFF, BASIC_DATA, {"on": False}, {}) await trt_on.execute(trait.COMMAND_ON_OFF, BASIC_DATA, {"on": False}, {})
assert len(off_calls) == 1 assert len(off_calls) == 1
assert off_calls[0].data == {ATTR_ENTITY_ID: "input_boolean.bla"} assert off_calls[0].data == {ATTR_ENTITY_ID: "input_boolean.bla"}
@ -282,12 +282,12 @@ async def test_onoff_switch(hass: HomeAssistant) -> None:
assert trt_assumed.sync_attributes() == {"commandOnlyOnOff": True} assert trt_assumed.sync_attributes() == {"commandOnlyOnOff": True}
on_calls = async_mock_service(hass, switch.DOMAIN, SERVICE_TURN_ON) on_calls = async_mock_service(hass, switch.DOMAIN, SERVICE_TURN_ON)
await trt_on.execute(trait.COMMAND_ONOFF, BASIC_DATA, {"on": True}, {}) await trt_on.execute(trait.COMMAND_ON_OFF, BASIC_DATA, {"on": True}, {})
assert len(on_calls) == 1 assert len(on_calls) == 1
assert on_calls[0].data == {ATTR_ENTITY_ID: "switch.bla"} assert on_calls[0].data == {ATTR_ENTITY_ID: "switch.bla"}
off_calls = async_mock_service(hass, switch.DOMAIN, SERVICE_TURN_OFF) off_calls = async_mock_service(hass, switch.DOMAIN, SERVICE_TURN_OFF)
await trt_on.execute(trait.COMMAND_ONOFF, BASIC_DATA, {"on": False}, {}) await trt_on.execute(trait.COMMAND_ON_OFF, BASIC_DATA, {"on": False}, {})
assert len(off_calls) == 1 assert len(off_calls) == 1
assert off_calls[0].data == {ATTR_ENTITY_ID: "switch.bla"} assert off_calls[0].data == {ATTR_ENTITY_ID: "switch.bla"}
@ -307,12 +307,12 @@ async def test_onoff_fan(hass: HomeAssistant) -> None:
assert trt_off.query_attributes() == {"on": False} assert trt_off.query_attributes() == {"on": False}
on_calls = async_mock_service(hass, fan.DOMAIN, SERVICE_TURN_ON) on_calls = async_mock_service(hass, fan.DOMAIN, SERVICE_TURN_ON)
await trt_on.execute(trait.COMMAND_ONOFF, BASIC_DATA, {"on": True}, {}) await trt_on.execute(trait.COMMAND_ON_OFF, BASIC_DATA, {"on": True}, {})
assert len(on_calls) == 1 assert len(on_calls) == 1
assert on_calls[0].data == {ATTR_ENTITY_ID: "fan.bla"} assert on_calls[0].data == {ATTR_ENTITY_ID: "fan.bla"}
off_calls = async_mock_service(hass, fan.DOMAIN, SERVICE_TURN_OFF) off_calls = async_mock_service(hass, fan.DOMAIN, SERVICE_TURN_OFF)
await trt_on.execute(trait.COMMAND_ONOFF, BASIC_DATA, {"on": False}, {}) await trt_on.execute(trait.COMMAND_ON_OFF, BASIC_DATA, {"on": False}, {})
assert len(off_calls) == 1 assert len(off_calls) == 1
assert off_calls[0].data == {ATTR_ENTITY_ID: "fan.bla"} assert off_calls[0].data == {ATTR_ENTITY_ID: "fan.bla"}
@ -333,12 +333,12 @@ async def test_onoff_light(hass: HomeAssistant) -> None:
assert trt_off.query_attributes() == {"on": False} assert trt_off.query_attributes() == {"on": False}
on_calls = async_mock_service(hass, light.DOMAIN, SERVICE_TURN_ON) on_calls = async_mock_service(hass, light.DOMAIN, SERVICE_TURN_ON)
await trt_on.execute(trait.COMMAND_ONOFF, BASIC_DATA, {"on": True}, {}) await trt_on.execute(trait.COMMAND_ON_OFF, BASIC_DATA, {"on": True}, {})
assert len(on_calls) == 1 assert len(on_calls) == 1
assert on_calls[0].data == {ATTR_ENTITY_ID: "light.bla"} assert on_calls[0].data == {ATTR_ENTITY_ID: "light.bla"}
off_calls = async_mock_service(hass, light.DOMAIN, SERVICE_TURN_OFF) off_calls = async_mock_service(hass, light.DOMAIN, SERVICE_TURN_OFF)
await trt_on.execute(trait.COMMAND_ONOFF, BASIC_DATA, {"on": False}, {}) await trt_on.execute(trait.COMMAND_ON_OFF, BASIC_DATA, {"on": False}, {})
assert len(off_calls) == 1 assert len(off_calls) == 1
assert off_calls[0].data == {ATTR_ENTITY_ID: "light.bla"} assert off_calls[0].data == {ATTR_ENTITY_ID: "light.bla"}
@ -359,13 +359,13 @@ async def test_onoff_media_player(hass: HomeAssistant) -> None:
assert trt_off.query_attributes() == {"on": False} assert trt_off.query_attributes() == {"on": False}
on_calls = async_mock_service(hass, media_player.DOMAIN, SERVICE_TURN_ON) on_calls = async_mock_service(hass, media_player.DOMAIN, SERVICE_TURN_ON)
await trt_on.execute(trait.COMMAND_ONOFF, BASIC_DATA, {"on": True}, {}) await trt_on.execute(trait.COMMAND_ON_OFF, BASIC_DATA, {"on": True}, {})
assert len(on_calls) == 1 assert len(on_calls) == 1
assert on_calls[0].data == {ATTR_ENTITY_ID: "media_player.bla"} assert on_calls[0].data == {ATTR_ENTITY_ID: "media_player.bla"}
off_calls = async_mock_service(hass, media_player.DOMAIN, SERVICE_TURN_OFF) off_calls = async_mock_service(hass, media_player.DOMAIN, SERVICE_TURN_OFF)
await trt_on.execute(trait.COMMAND_ONOFF, BASIC_DATA, {"on": False}, {}) await trt_on.execute(trait.COMMAND_ON_OFF, BASIC_DATA, {"on": False}, {})
assert len(off_calls) == 1 assert len(off_calls) == 1
assert off_calls[0].data == {ATTR_ENTITY_ID: "media_player.bla"} assert off_calls[0].data == {ATTR_ENTITY_ID: "media_player.bla"}
@ -386,13 +386,13 @@ async def test_onoff_humidifier(hass: HomeAssistant) -> None:
assert trt_off.query_attributes() == {"on": False} assert trt_off.query_attributes() == {"on": False}
on_calls = async_mock_service(hass, humidifier.DOMAIN, SERVICE_TURN_ON) on_calls = async_mock_service(hass, humidifier.DOMAIN, SERVICE_TURN_ON)
await trt_on.execute(trait.COMMAND_ONOFF, BASIC_DATA, {"on": True}, {}) await trt_on.execute(trait.COMMAND_ON_OFF, BASIC_DATA, {"on": True}, {})
assert len(on_calls) == 1 assert len(on_calls) == 1
assert on_calls[0].data == {ATTR_ENTITY_ID: "humidifier.bla"} assert on_calls[0].data == {ATTR_ENTITY_ID: "humidifier.bla"}
off_calls = async_mock_service(hass, humidifier.DOMAIN, SERVICE_TURN_OFF) off_calls = async_mock_service(hass, humidifier.DOMAIN, SERVICE_TURN_OFF)
await trt_on.execute(trait.COMMAND_ONOFF, BASIC_DATA, {"on": False}, {}) await trt_on.execute(trait.COMMAND_ON_OFF, BASIC_DATA, {"on": False}, {})
assert len(off_calls) == 1 assert len(off_calls) == 1
assert off_calls[0].data == {ATTR_ENTITY_ID: "humidifier.bla"} assert off_calls[0].data == {ATTR_ENTITY_ID: "humidifier.bla"}
@ -415,13 +415,13 @@ async def test_onoff_water_heater(hass: HomeAssistant) -> None:
assert trt_off.query_attributes() == {"on": False} assert trt_off.query_attributes() == {"on": False}
on_calls = async_mock_service(hass, water_heater.DOMAIN, SERVICE_TURN_ON) on_calls = async_mock_service(hass, water_heater.DOMAIN, SERVICE_TURN_ON)
await trt_on.execute(trait.COMMAND_ONOFF, BASIC_DATA, {"on": True}, {}) await trt_on.execute(trait.COMMAND_ON_OFF, BASIC_DATA, {"on": True}, {})
assert len(on_calls) == 1 assert len(on_calls) == 1
assert on_calls[0].data == {ATTR_ENTITY_ID: "water_heater.bla"} assert on_calls[0].data == {ATTR_ENTITY_ID: "water_heater.bla"}
off_calls = async_mock_service(hass, water_heater.DOMAIN, SERVICE_TURN_OFF) off_calls = async_mock_service(hass, water_heater.DOMAIN, SERVICE_TURN_OFF)
await trt_on.execute(trait.COMMAND_ONOFF, BASIC_DATA, {"on": False}, {}) await trt_on.execute(trait.COMMAND_ON_OFF, BASIC_DATA, {"on": False}, {})
assert len(off_calls) == 1 assert len(off_calls) == 1
assert off_calls[0].data == {ATTR_ENTITY_ID: "water_heater.bla"} assert off_calls[0].data == {ATTR_ENTITY_ID: "water_heater.bla"}
@ -562,22 +562,22 @@ async def test_startstop_vacuum(hass: HomeAssistant) -> None:
assert trt.query_attributes() == {"isRunning": False, "isPaused": True} assert trt.query_attributes() == {"isRunning": False, "isPaused": True}
start_calls = async_mock_service(hass, vacuum.DOMAIN, vacuum.SERVICE_START) start_calls = async_mock_service(hass, vacuum.DOMAIN, vacuum.SERVICE_START)
await trt.execute(trait.COMMAND_STARTSTOP, BASIC_DATA, {"start": True}, {}) await trt.execute(trait.COMMAND_START_STOP, BASIC_DATA, {"start": True}, {})
assert len(start_calls) == 1 assert len(start_calls) == 1
assert start_calls[0].data == {ATTR_ENTITY_ID: "vacuum.bla"} assert start_calls[0].data == {ATTR_ENTITY_ID: "vacuum.bla"}
stop_calls = async_mock_service(hass, vacuum.DOMAIN, vacuum.SERVICE_STOP) stop_calls = async_mock_service(hass, vacuum.DOMAIN, vacuum.SERVICE_STOP)
await trt.execute(trait.COMMAND_STARTSTOP, BASIC_DATA, {"start": False}, {}) await trt.execute(trait.COMMAND_START_STOP, BASIC_DATA, {"start": False}, {})
assert len(stop_calls) == 1 assert len(stop_calls) == 1
assert stop_calls[0].data == {ATTR_ENTITY_ID: "vacuum.bla"} assert stop_calls[0].data == {ATTR_ENTITY_ID: "vacuum.bla"}
pause_calls = async_mock_service(hass, vacuum.DOMAIN, vacuum.SERVICE_PAUSE) pause_calls = async_mock_service(hass, vacuum.DOMAIN, vacuum.SERVICE_PAUSE)
await trt.execute(trait.COMMAND_PAUSEUNPAUSE, BASIC_DATA, {"pause": True}, {}) await trt.execute(trait.COMMAND_PAUSE_UNPAUSE, BASIC_DATA, {"pause": True}, {})
assert len(pause_calls) == 1 assert len(pause_calls) == 1
assert pause_calls[0].data == {ATTR_ENTITY_ID: "vacuum.bla"} assert pause_calls[0].data == {ATTR_ENTITY_ID: "vacuum.bla"}
unpause_calls = async_mock_service(hass, vacuum.DOMAIN, vacuum.SERVICE_START) unpause_calls = async_mock_service(hass, vacuum.DOMAIN, vacuum.SERVICE_START)
await trt.execute(trait.COMMAND_PAUSEUNPAUSE, BASIC_DATA, {"pause": False}, {}) await trt.execute(trait.COMMAND_PAUSE_UNPAUSE, BASIC_DATA, {"pause": False}, {})
assert len(unpause_calls) == 1 assert len(unpause_calls) == 1
assert unpause_calls[0].data == {ATTR_ENTITY_ID: "vacuum.bla"} assert unpause_calls[0].data == {ATTR_ENTITY_ID: "vacuum.bla"}
@ -665,7 +665,7 @@ async def test_startstop_cover_valve(
open_calls = async_mock_service(hass, domain, service_open) open_calls = async_mock_service(hass, domain, service_open)
close_calls = async_mock_service(hass, domain, service_close) close_calls = async_mock_service(hass, domain, service_close)
toggle_calls = async_mock_service(hass, domain, service_toggle) toggle_calls = async_mock_service(hass, domain, service_toggle)
await trt.execute(trait.COMMAND_STARTSTOP, BASIC_DATA, {"start": False}, {}) await trt.execute(trait.COMMAND_START_STOP, BASIC_DATA, {"start": False}, {})
assert len(stop_calls) == 1 assert len(stop_calls) == 1
assert stop_calls[0].data == {ATTR_ENTITY_ID: f"{domain}.bla"} assert stop_calls[0].data == {ATTR_ENTITY_ID: f"{domain}.bla"}
@ -681,18 +681,18 @@ async def test_startstop_cover_valve(
with pytest.raises( with pytest.raises(
SmartHomeError, match=f"{domain.capitalize()} is already stopped" SmartHomeError, match=f"{domain.capitalize()} is already stopped"
): ):
await trt.execute(trait.COMMAND_STARTSTOP, BASIC_DATA, {"start": False}, {}) await trt.execute(trait.COMMAND_START_STOP, BASIC_DATA, {"start": False}, {})
# Start triggers toggle open # Start triggers toggle open
state.state = state_closed state.state = state_closed
await trt.execute(trait.COMMAND_STARTSTOP, BASIC_DATA, {"start": True}, {}) await trt.execute(trait.COMMAND_START_STOP, BASIC_DATA, {"start": True}, {})
assert len(open_calls) == 0 assert len(open_calls) == 0
assert len(close_calls) == 0 assert len(close_calls) == 0
assert len(toggle_calls) == 1 assert len(toggle_calls) == 1
assert toggle_calls[0].data == {ATTR_ENTITY_ID: f"{domain}.bla"} assert toggle_calls[0].data == {ATTR_ENTITY_ID: f"{domain}.bla"}
# Second start triggers toggle close # Second start triggers toggle close
state.state = state_open state.state = state_open
await trt.execute(trait.COMMAND_STARTSTOP, BASIC_DATA, {"start": True}, {}) await trt.execute(trait.COMMAND_START_STOP, BASIC_DATA, {"start": True}, {})
assert len(open_calls) == 0 assert len(open_calls) == 0
assert len(close_calls) == 0 assert len(close_calls) == 0
assert len(toggle_calls) == 2 assert len(toggle_calls) == 2
@ -703,7 +703,7 @@ async def test_startstop_cover_valve(
SmartHomeError, SmartHomeError,
match="Command action.devices.commands.PauseUnpause is not supported", match="Command action.devices.commands.PauseUnpause is not supported",
): ):
await trt.execute(trait.COMMAND_PAUSEUNPAUSE, BASIC_DATA, {"start": True}, {}) await trt.execute(trait.COMMAND_PAUSE_UNPAUSE, BASIC_DATA, {"start": True}, {})
@pytest.mark.parametrize( @pytest.mark.parametrize(
@ -779,13 +779,13 @@ async def test_startstop_cover_valve_assumed(
stop_calls = async_mock_service(hass, domain, service_stop) stop_calls = async_mock_service(hass, domain, service_stop)
toggle_calls = async_mock_service(hass, domain, service_toggle) toggle_calls = async_mock_service(hass, domain, service_toggle)
await trt.execute(trait.COMMAND_STARTSTOP, BASIC_DATA, {"start": False}, {}) await trt.execute(trait.COMMAND_START_STOP, BASIC_DATA, {"start": False}, {})
assert len(stop_calls) == 1 assert len(stop_calls) == 1
assert len(toggle_calls) == 0 assert len(toggle_calls) == 0
assert stop_calls[0].data == {ATTR_ENTITY_ID: f"{domain}.bla"} assert stop_calls[0].data == {ATTR_ENTITY_ID: f"{domain}.bla"}
stop_calls.clear() stop_calls.clear()
await trt.execute(trait.COMMAND_STARTSTOP, BASIC_DATA, {"start": True}, {}) await trt.execute(trait.COMMAND_START_STOP, BASIC_DATA, {"start": True}, {})
assert len(stop_calls) == 0 assert len(stop_calls) == 0
assert len(toggle_calls) == 1 assert len(toggle_calls) == 1
assert toggle_calls[0].data == {ATTR_ENTITY_ID: f"{domain}.bla"} assert toggle_calls[0].data == {ATTR_ENTITY_ID: f"{domain}.bla"}
@ -984,13 +984,13 @@ async def test_light_modes(hass: HomeAssistant) -> None:
} }
assert trt.can_execute( assert trt.can_execute(
trait.COMMAND_MODES, trait.COMMAND_SET_MODES,
params={"updateModeSettings": {"effect": "colorloop"}}, params={"updateModeSettings": {"effect": "colorloop"}},
) )
calls = async_mock_service(hass, light.DOMAIN, SERVICE_TURN_ON) calls = async_mock_service(hass, light.DOMAIN, SERVICE_TURN_ON)
await trt.execute( await trt.execute(
trait.COMMAND_MODES, trait.COMMAND_SET_MODES,
BASIC_DATA, BASIC_DATA,
{"updateModeSettings": {"effect": "colorloop"}}, {"updateModeSettings": {"effect": "colorloop"}},
{}, {},
@ -1422,7 +1422,7 @@ async def test_temperature_control(hass: HomeAssistant) -> None:
"temperatureAmbientCelsius": 18, "temperatureAmbientCelsius": 18,
} }
with pytest.raises(helpers.SmartHomeError) as err: with pytest.raises(helpers.SmartHomeError) as err:
await trt.execute(trait.COMMAND_ONOFF, BASIC_DATA, {"on": False}, {}) await trt.execute(trait.COMMAND_ON_OFF, BASIC_DATA, {"on": False}, {})
assert err.value.code == const.ERR_NOT_SUPPORTED assert err.value.code == const.ERR_NOT_SUPPORTED
@ -1609,11 +1609,11 @@ async def test_lock_unlock_lock(hass: HomeAssistant) -> None:
assert trt.query_attributes() == {"isLocked": True} assert trt.query_attributes() == {"isLocked": True}
assert trt.can_execute(trait.COMMAND_LOCKUNLOCK, {"lock": True}) assert trt.can_execute(trait.COMMAND_LOCK_UNLOCK, {"lock": True})
calls = async_mock_service(hass, lock.DOMAIN, lock.SERVICE_LOCK) calls = async_mock_service(hass, lock.DOMAIN, lock.SERVICE_LOCK)
await trt.execute(trait.COMMAND_LOCKUNLOCK, PIN_DATA, {"lock": True}, {}) await trt.execute(trait.COMMAND_LOCK_UNLOCK, PIN_DATA, {"lock": True}, {})
assert len(calls) == 1 assert len(calls) == 1
assert calls[0].data == {ATTR_ENTITY_ID: "lock.front_door"} assert calls[0].data == {ATTR_ENTITY_ID: "lock.front_door"}
@ -1652,11 +1652,11 @@ async def test_lock_unlock_lock_jammed(hass: HomeAssistant) -> None:
assert trt.query_attributes() == {"isJammed": True} assert trt.query_attributes() == {"isJammed": True}
assert trt.can_execute(trait.COMMAND_LOCKUNLOCK, {"lock": True}) assert trt.can_execute(trait.COMMAND_LOCK_UNLOCK, {"lock": True})
calls = async_mock_service(hass, lock.DOMAIN, lock.SERVICE_LOCK) calls = async_mock_service(hass, lock.DOMAIN, lock.SERVICE_LOCK)
await trt.execute(trait.COMMAND_LOCKUNLOCK, PIN_DATA, {"lock": True}, {}) await trt.execute(trait.COMMAND_LOCK_UNLOCK, PIN_DATA, {"lock": True}, {})
assert len(calls) == 1 assert len(calls) == 1
assert calls[0].data == {ATTR_ENTITY_ID: "lock.front_door"} assert calls[0].data == {ATTR_ENTITY_ID: "lock.front_door"}
@ -1677,13 +1677,13 @@ async def test_lock_unlock_unlock(hass: HomeAssistant) -> None:
assert trt.query_attributes() == {"isLocked": True} assert trt.query_attributes() == {"isLocked": True}
assert trt.can_execute(trait.COMMAND_LOCKUNLOCK, {"lock": False}) assert trt.can_execute(trait.COMMAND_LOCK_UNLOCK, {"lock": False})
calls = async_mock_service(hass, lock.DOMAIN, lock.SERVICE_UNLOCK) calls = async_mock_service(hass, lock.DOMAIN, lock.SERVICE_UNLOCK)
# No challenge data # No challenge data
with pytest.raises(error.ChallengeNeeded) as err: with pytest.raises(error.ChallengeNeeded) as err:
await trt.execute(trait.COMMAND_LOCKUNLOCK, PIN_DATA, {"lock": False}, {}) await trt.execute(trait.COMMAND_LOCK_UNLOCK, PIN_DATA, {"lock": False}, {})
assert len(calls) == 0 assert len(calls) == 0
assert err.value.code == const.ERR_CHALLENGE_NEEDED assert err.value.code == const.ERR_CHALLENGE_NEEDED
assert err.value.challenge_type == const.CHALLENGE_PIN_NEEDED assert err.value.challenge_type == const.CHALLENGE_PIN_NEEDED
@ -1691,14 +1691,14 @@ async def test_lock_unlock_unlock(hass: HomeAssistant) -> None:
# invalid pin # invalid pin
with pytest.raises(error.ChallengeNeeded) as err: with pytest.raises(error.ChallengeNeeded) as err:
await trt.execute( await trt.execute(
trait.COMMAND_LOCKUNLOCK, PIN_DATA, {"lock": False}, {"pin": 9999} trait.COMMAND_LOCK_UNLOCK, PIN_DATA, {"lock": False}, {"pin": 9999}
) )
assert len(calls) == 0 assert len(calls) == 0
assert err.value.code == const.ERR_CHALLENGE_NEEDED assert err.value.code == const.ERR_CHALLENGE_NEEDED
assert err.value.challenge_type == const.CHALLENGE_FAILED_PIN_NEEDED assert err.value.challenge_type == const.CHALLENGE_FAILED_PIN_NEEDED
await trt.execute( await trt.execute(
trait.COMMAND_LOCKUNLOCK, PIN_DATA, {"lock": False}, {"pin": "1234"} trait.COMMAND_LOCK_UNLOCK, PIN_DATA, {"lock": False}, {"pin": "1234"}
) )
assert len(calls) == 1 assert len(calls) == 1
@ -1710,7 +1710,7 @@ async def test_lock_unlock_unlock(hass: HomeAssistant) -> None:
) )
with pytest.raises(error.SmartHomeError) as err: with pytest.raises(error.SmartHomeError) as err:
await trt.execute(trait.COMMAND_LOCKUNLOCK, BASIC_DATA, {"lock": False}, {}) await trt.execute(trait.COMMAND_LOCK_UNLOCK, BASIC_DATA, {"lock": False}, {})
assert len(calls) == 1 assert len(calls) == 1
assert err.value.code == const.ERR_CHALLENGE_NOT_SETUP assert err.value.code == const.ERR_CHALLENGE_NOT_SETUP
@ -1720,7 +1720,7 @@ async def test_lock_unlock_unlock(hass: HomeAssistant) -> None:
"should_2fa", "should_2fa",
return_value=False, return_value=False,
): ):
await trt.execute(trait.COMMAND_LOCKUNLOCK, BASIC_DATA, {"lock": False}, {}) await trt.execute(trait.COMMAND_LOCK_UNLOCK, BASIC_DATA, {"lock": False}, {})
assert len(calls) == 2 assert len(calls) == 2
@ -1769,7 +1769,7 @@ async def test_arm_disarm_arm_away(hass: HomeAssistant) -> None:
} }
assert trt.can_execute( assert trt.can_execute(
trait.COMMAND_ARMDISARM, {"arm": True, "armLevel": STATE_ALARM_ARMED_AWAY} trait.COMMAND_ARM_DISARM, {"arm": True, "armLevel": STATE_ALARM_ARMED_AWAY}
) )
calls = async_mock_service( calls = async_mock_service(
@ -1789,7 +1789,7 @@ async def test_arm_disarm_arm_away(hass: HomeAssistant) -> None:
) )
with pytest.raises(error.SmartHomeError) as err: with pytest.raises(error.SmartHomeError) as err:
await trt.execute( await trt.execute(
trait.COMMAND_ARMDISARM, trait.COMMAND_ARM_DISARM,
BASIC_DATA, BASIC_DATA,
{"arm": True, "armLevel": STATE_ALARM_ARMED_AWAY}, {"arm": True, "armLevel": STATE_ALARM_ARMED_AWAY},
{}, {},
@ -1809,7 +1809,7 @@ async def test_arm_disarm_arm_away(hass: HomeAssistant) -> None:
# No challenge data # No challenge data
with pytest.raises(error.ChallengeNeeded) as err: with pytest.raises(error.ChallengeNeeded) as err:
await trt.execute( await trt.execute(
trait.COMMAND_ARMDISARM, trait.COMMAND_ARM_DISARM,
PIN_DATA, PIN_DATA,
{"arm": True, "armLevel": STATE_ALARM_ARMED_AWAY}, {"arm": True, "armLevel": STATE_ALARM_ARMED_AWAY},
{}, {},
@ -1821,7 +1821,7 @@ async def test_arm_disarm_arm_away(hass: HomeAssistant) -> None:
# invalid pin # invalid pin
with pytest.raises(error.ChallengeNeeded) as err: with pytest.raises(error.ChallengeNeeded) as err:
await trt.execute( await trt.execute(
trait.COMMAND_ARMDISARM, trait.COMMAND_ARM_DISARM,
PIN_DATA, PIN_DATA,
{"arm": True, "armLevel": STATE_ALARM_ARMED_AWAY}, {"arm": True, "armLevel": STATE_ALARM_ARMED_AWAY},
{"pin": 9999}, {"pin": 9999},
@ -1832,7 +1832,7 @@ async def test_arm_disarm_arm_away(hass: HomeAssistant) -> None:
# correct pin # correct pin
await trt.execute( await trt.execute(
trait.COMMAND_ARMDISARM, trait.COMMAND_ARM_DISARM,
PIN_DATA, PIN_DATA,
{"arm": True, "armLevel": STATE_ALARM_ARMED_AWAY}, {"arm": True, "armLevel": STATE_ALARM_ARMED_AWAY},
{"pin": "1234"}, {"pin": "1234"},
@ -1852,7 +1852,7 @@ async def test_arm_disarm_arm_away(hass: HomeAssistant) -> None:
) )
with pytest.raises(error.SmartHomeError) as err: with pytest.raises(error.SmartHomeError) as err:
await trt.execute( await trt.execute(
trait.COMMAND_ARMDISARM, trait.COMMAND_ARM_DISARM,
PIN_DATA, PIN_DATA,
{"arm": True, "armLevel": STATE_ALARM_ARMED_AWAY}, {"arm": True, "armLevel": STATE_ALARM_ARMED_AWAY},
{}, {},
@ -1871,7 +1871,7 @@ async def test_arm_disarm_arm_away(hass: HomeAssistant) -> None:
PIN_CONFIG, PIN_CONFIG,
) )
await trt.execute( await trt.execute(
trait.COMMAND_ARMDISARM, trait.COMMAND_ARM_DISARM,
PIN_DATA, PIN_DATA,
{"arm": True, "armLevel": STATE_ALARM_ARMED_AWAY}, {"arm": True, "armLevel": STATE_ALARM_ARMED_AWAY},
{}, {},
@ -1880,7 +1880,7 @@ async def test_arm_disarm_arm_away(hass: HomeAssistant) -> None:
with pytest.raises(error.SmartHomeError) as err: with pytest.raises(error.SmartHomeError) as err:
await trt.execute( await trt.execute(
trait.COMMAND_ARMDISARM, trait.COMMAND_ARM_DISARM,
PIN_DATA, PIN_DATA,
{"arm": True}, {"arm": True},
{}, {},
@ -1942,7 +1942,7 @@ async def test_arm_disarm_disarm(hass: HomeAssistant) -> None:
"isArmed": False, "isArmed": False,
} }
assert trt.can_execute(trait.COMMAND_ARMDISARM, {"arm": False}) assert trt.can_execute(trait.COMMAND_ARM_DISARM, {"arm": False})
calls = async_mock_service( calls = async_mock_service(
hass, alarm_control_panel.DOMAIN, alarm_control_panel.SERVICE_ALARM_DISARM hass, alarm_control_panel.DOMAIN, alarm_control_panel.SERVICE_ALARM_DISARM
@ -1959,7 +1959,7 @@ async def test_arm_disarm_disarm(hass: HomeAssistant) -> None:
BASIC_CONFIG, BASIC_CONFIG,
) )
with pytest.raises(error.SmartHomeError) as err: with pytest.raises(error.SmartHomeError) as err:
await trt.execute(trait.COMMAND_ARMDISARM, BASIC_DATA, {"arm": False}, {}) await trt.execute(trait.COMMAND_ARM_DISARM, BASIC_DATA, {"arm": False}, {})
assert len(calls) == 0 assert len(calls) == 0
assert err.value.code == const.ERR_CHALLENGE_NOT_SETUP assert err.value.code == const.ERR_CHALLENGE_NOT_SETUP
@ -1976,7 +1976,7 @@ async def test_arm_disarm_disarm(hass: HomeAssistant) -> None:
# No challenge data # No challenge data
with pytest.raises(error.ChallengeNeeded) as err: with pytest.raises(error.ChallengeNeeded) as err:
await trt.execute(trait.COMMAND_ARMDISARM, PIN_DATA, {"arm": False}, {}) await trt.execute(trait.COMMAND_ARM_DISARM, PIN_DATA, {"arm": False}, {})
assert len(calls) == 0 assert len(calls) == 0
assert err.value.code == const.ERR_CHALLENGE_NEEDED assert err.value.code == const.ERR_CHALLENGE_NEEDED
assert err.value.challenge_type == const.CHALLENGE_PIN_NEEDED assert err.value.challenge_type == const.CHALLENGE_PIN_NEEDED
@ -1984,7 +1984,7 @@ async def test_arm_disarm_disarm(hass: HomeAssistant) -> None:
# invalid pin # invalid pin
with pytest.raises(error.ChallengeNeeded) as err: with pytest.raises(error.ChallengeNeeded) as err:
await trt.execute( await trt.execute(
trait.COMMAND_ARMDISARM, PIN_DATA, {"arm": False}, {"pin": 9999} trait.COMMAND_ARM_DISARM, PIN_DATA, {"arm": False}, {"pin": 9999}
) )
assert len(calls) == 0 assert len(calls) == 0
assert err.value.code == const.ERR_CHALLENGE_NEEDED assert err.value.code == const.ERR_CHALLENGE_NEEDED
@ -1992,7 +1992,7 @@ async def test_arm_disarm_disarm(hass: HomeAssistant) -> None:
# correct pin # correct pin
await trt.execute( await trt.execute(
trait.COMMAND_ARMDISARM, PIN_DATA, {"arm": False}, {"pin": "1234"} trait.COMMAND_ARM_DISARM, PIN_DATA, {"arm": False}, {"pin": "1234"}
) )
assert len(calls) == 1 assert len(calls) == 1
@ -2008,7 +2008,7 @@ async def test_arm_disarm_disarm(hass: HomeAssistant) -> None:
PIN_CONFIG, PIN_CONFIG,
) )
with pytest.raises(error.SmartHomeError) as err: with pytest.raises(error.SmartHomeError) as err:
await trt.execute(trait.COMMAND_ARMDISARM, PIN_DATA, {"arm": False}, {}) await trt.execute(trait.COMMAND_ARM_DISARM, PIN_DATA, {"arm": False}, {})
assert len(calls) == 1 assert len(calls) == 1
assert err.value.code == const.ERR_ALREADY_DISARMED assert err.value.code == const.ERR_ALREADY_DISARMED
@ -2025,7 +2025,7 @@ async def test_arm_disarm_disarm(hass: HomeAssistant) -> None:
# Cancel arming after already armed will require pin # Cancel arming after already armed will require pin
with pytest.raises(error.SmartHomeError) as err: with pytest.raises(error.SmartHomeError) as err:
await trt.execute( await trt.execute(
trait.COMMAND_ARMDISARM, PIN_DATA, {"arm": True, "cancel": True}, {} trait.COMMAND_ARM_DISARM, PIN_DATA, {"arm": True, "cancel": True}, {}
) )
assert len(calls) == 1 assert len(calls) == 1
assert err.value.code == const.ERR_CHALLENGE_NEEDED assert err.value.code == const.ERR_CHALLENGE_NEEDED
@ -2042,7 +2042,7 @@ async def test_arm_disarm_disarm(hass: HomeAssistant) -> None:
PIN_CONFIG, PIN_CONFIG,
) )
await trt.execute( await trt.execute(
trait.COMMAND_ARMDISARM, PIN_DATA, {"arm": True, "cancel": True}, {} trait.COMMAND_ARM_DISARM, PIN_DATA, {"arm": True, "cancel": True}, {}
) )
assert len(calls) == 2 assert len(calls) == 2
@ -2078,10 +2078,12 @@ async def test_fan_speed(hass: HomeAssistant) -> None:
"currentFanSpeedSetting": ANY, "currentFanSpeedSetting": ANY,
} }
assert trt.can_execute(trait.COMMAND_FANSPEED, params={"fanSpeedPercent": 10}) assert trt.can_execute(trait.COMMAND_SET_FAN_SPEED, params={"fanSpeedPercent": 10})
calls = async_mock_service(hass, fan.DOMAIN, fan.SERVICE_SET_PERCENTAGE) calls = async_mock_service(hass, fan.DOMAIN, fan.SERVICE_SET_PERCENTAGE)
await trt.execute(trait.COMMAND_FANSPEED, BASIC_DATA, {"fanSpeedPercent": 10}, {}) await trt.execute(
trait.COMMAND_SET_FAN_SPEED, BASIC_DATA, {"fanSpeedPercent": 10}, {}
)
assert len(calls) == 1 assert len(calls) == 1
assert calls[0].data == {"entity_id": "fan.living_room_fan", "percentage": 10} assert calls[0].data == {"entity_id": "fan.living_room_fan", "percentage": 10}
@ -2216,10 +2218,10 @@ async def test_fan_speed_ordered(
"currentFanSpeedSetting": speed, "currentFanSpeedSetting": speed,
} }
assert trt.can_execute(trait.COMMAND_FANSPEED, params={"fanSpeed": speed}) assert trt.can_execute(trait.COMMAND_SET_FAN_SPEED, params={"fanSpeed": speed})
calls = async_mock_service(hass, fan.DOMAIN, fan.SERVICE_SET_PERCENTAGE) calls = async_mock_service(hass, fan.DOMAIN, fan.SERVICE_SET_PERCENTAGE)
await trt.execute(trait.COMMAND_FANSPEED, BASIC_DATA, {"fanSpeed": speed}, {}) await trt.execute(trait.COMMAND_SET_FAN_SPEED, BASIC_DATA, {"fanSpeed": speed}, {})
assert len(calls) == 1 assert len(calls) == 1
assert calls[0].data == { assert calls[0].data == {
@ -2328,10 +2330,12 @@ async def test_climate_fan_speed(hass: HomeAssistant) -> None:
"currentFanSpeedSetting": "low", "currentFanSpeedSetting": "low",
} }
assert trt.can_execute(trait.COMMAND_FANSPEED, params={"fanSpeed": "medium"}) assert trt.can_execute(trait.COMMAND_SET_FAN_SPEED, params={"fanSpeed": "medium"})
calls = async_mock_service(hass, climate.DOMAIN, climate.SERVICE_SET_FAN_MODE) calls = async_mock_service(hass, climate.DOMAIN, climate.SERVICE_SET_FAN_MODE)
await trt.execute(trait.COMMAND_FANSPEED, BASIC_DATA, {"fanSpeed": "medium"}, {}) await trt.execute(
trait.COMMAND_SET_FAN_SPEED, BASIC_DATA, {"fanSpeed": "medium"}, {}
)
assert len(calls) == 1 assert len(calls) == 1
assert calls[0].data == { assert calls[0].data == {
@ -2387,7 +2391,7 @@ async def test_inputselector(hass: HomeAssistant) -> None:
} }
assert trt.can_execute( assert trt.can_execute(
trait.COMMAND_INPUT, trait.COMMAND_SET_INPUT,
params={"newInput": "media"}, params={"newInput": "media"},
) )
@ -2395,7 +2399,7 @@ async def test_inputselector(hass: HomeAssistant) -> None:
hass, media_player.DOMAIN, media_player.SERVICE_SELECT_SOURCE hass, media_player.DOMAIN, media_player.SERVICE_SELECT_SOURCE
) )
await trt.execute( await trt.execute(
trait.COMMAND_INPUT, trait.COMMAND_SET_INPUT,
BASIC_DATA, BASIC_DATA,
{"newInput": "media"}, {"newInput": "media"},
{}, {},
@ -2563,7 +2567,7 @@ async def test_modes_input_select(hass: HomeAssistant) -> None:
} }
assert trt.can_execute( assert trt.can_execute(
trait.COMMAND_MODES, trait.COMMAND_SET_MODES,
params={"updateModeSettings": {"option": "xyz"}}, params={"updateModeSettings": {"option": "xyz"}},
) )
@ -2571,7 +2575,7 @@ async def test_modes_input_select(hass: HomeAssistant) -> None:
hass, input_select.DOMAIN, input_select.SERVICE_SELECT_OPTION hass, input_select.DOMAIN, input_select.SERVICE_SELECT_OPTION
) )
await trt.execute( await trt.execute(
trait.COMMAND_MODES, trait.COMMAND_SET_MODES,
BASIC_DATA, BASIC_DATA,
{"updateModeSettings": {"option": "xyz"}}, {"updateModeSettings": {"option": "xyz"}},
{}, {},
@ -2639,13 +2643,13 @@ async def test_modes_select(hass: HomeAssistant) -> None:
} }
assert trt.can_execute( assert trt.can_execute(
trait.COMMAND_MODES, trait.COMMAND_SET_MODES,
params={"updateModeSettings": {"option": "xyz"}}, params={"updateModeSettings": {"option": "xyz"}},
) )
calls = async_mock_service(hass, select.DOMAIN, select.SERVICE_SELECT_OPTION) calls = async_mock_service(hass, select.DOMAIN, select.SERVICE_SELECT_OPTION)
await trt.execute( await trt.execute(
trait.COMMAND_MODES, trait.COMMAND_SET_MODES,
BASIC_DATA, BASIC_DATA,
{"updateModeSettings": {"option": "xyz"}}, {"updateModeSettings": {"option": "xyz"}},
{}, {},
@ -2716,12 +2720,12 @@ async def test_modes_humidifier(hass: HomeAssistant) -> None:
} }
assert trt.can_execute( assert trt.can_execute(
trait.COMMAND_MODES, params={"updateModeSettings": {"mode": "away"}} trait.COMMAND_SET_MODES, params={"updateModeSettings": {"mode": "away"}}
) )
calls = async_mock_service(hass, humidifier.DOMAIN, humidifier.SERVICE_SET_MODE) calls = async_mock_service(hass, humidifier.DOMAIN, humidifier.SERVICE_SET_MODE)
await trt.execute( await trt.execute(
trait.COMMAND_MODES, trait.COMMAND_SET_MODES,
BASIC_DATA, BASIC_DATA,
{"updateModeSettings": {"mode": "away"}}, {"updateModeSettings": {"mode": "away"}},
{}, {},
@ -2792,14 +2796,15 @@ async def test_modes_water_heater(hass: HomeAssistant) -> None:
} }
assert trt.can_execute( assert trt.can_execute(
trait.COMMAND_MODES, params={"updateModeSettings": {"operation mode": "gas"}} trait.COMMAND_SET_MODES,
params={"updateModeSettings": {"operation mode": "gas"}},
) )
calls = async_mock_service( calls = async_mock_service(
hass, water_heater.DOMAIN, water_heater.SERVICE_SET_OPERATION_MODE hass, water_heater.DOMAIN, water_heater.SERVICE_SET_OPERATION_MODE
) )
await trt.execute( await trt.execute(
trait.COMMAND_MODES, trait.COMMAND_SET_MODES,
BASIC_DATA, BASIC_DATA,
{"updateModeSettings": {"operation mode": "gas"}}, {"updateModeSettings": {"operation mode": "gas"}},
{}, {},
@ -2868,7 +2873,7 @@ async def test_sound_modes(hass: HomeAssistant) -> None:
} }
assert trt.can_execute( assert trt.can_execute(
trait.COMMAND_MODES, trait.COMMAND_SET_MODES,
params={"updateModeSettings": {"sound mode": "stereo"}}, params={"updateModeSettings": {"sound mode": "stereo"}},
) )
@ -2876,7 +2881,7 @@ async def test_sound_modes(hass: HomeAssistant) -> None:
hass, media_player.DOMAIN, media_player.SERVICE_SELECT_SOUND_MODE hass, media_player.DOMAIN, media_player.SERVICE_SELECT_SOUND_MODE
) )
await trt.execute( await trt.execute(
trait.COMMAND_MODES, trait.COMMAND_SET_MODES,
BASIC_DATA, BASIC_DATA,
{"updateModeSettings": {"sound mode": "stereo"}}, {"updateModeSettings": {"sound mode": "stereo"}},
{}, {},
@ -2941,13 +2946,13 @@ async def test_preset_modes(hass: HomeAssistant) -> None:
} }
assert trt.can_execute( assert trt.can_execute(
trait.COMMAND_MODES, trait.COMMAND_SET_MODES,
params={"updateModeSettings": {"preset mode": "auto"}}, params={"updateModeSettings": {"preset mode": "auto"}},
) )
calls = async_mock_service(hass, fan.DOMAIN, fan.SERVICE_SET_PRESET_MODE) calls = async_mock_service(hass, fan.DOMAIN, fan.SERVICE_SET_PRESET_MODE)
await trt.execute( await trt.execute(
trait.COMMAND_MODES, trait.COMMAND_SET_MODES,
BASIC_DATA, BASIC_DATA,
{"updateModeSettings": {"preset mode": "auto"}}, {"updateModeSettings": {"preset mode": "auto"}},
{}, {},
@ -2975,7 +2980,7 @@ async def test_traits_unknown_domains(
assert trt.supported("not_supported_domain", False, None, None) is False assert trt.supported("not_supported_domain", False, None, None) is False
await trt.execute( await trt.execute(
trait.COMMAND_MODES, trait.COMMAND_SET_MODES,
BASIC_DATA, BASIC_DATA,
{"updateModeSettings": {}}, {"updateModeSettings": {}},
{}, {},
@ -3049,9 +3054,9 @@ async def test_openclose_cover_valve(
calls_open = async_mock_service(hass, domain, open_service) calls_open = async_mock_service(hass, domain, open_service)
calls_close = async_mock_service(hass, domain, close_service) calls_close = async_mock_service(hass, domain, close_service)
await trt.execute(trait.COMMAND_OPENCLOSE, BASIC_DATA, {"openPercent": 50}, {}) await trt.execute(trait.COMMAND_OPEN_CLOSE, BASIC_DATA, {"openPercent": 50}, {})
await trt.execute( await trt.execute(
trait.COMMAND_OPENCLOSE_RELATIVE, BASIC_DATA, {"openRelativePercent": 50}, {} trait.COMMAND_OPEN_CLOSE_RELATIVE, BASIC_DATA, {"openRelativePercent": 50}, {}
) )
assert len(calls_set) == 1 assert len(calls_set) == 1
assert calls_set[0].data == { assert calls_set[0].data == {
@ -3066,9 +3071,9 @@ async def test_openclose_cover_valve(
assert len(calls_close) == 0 assert len(calls_close) == 0
await trt.execute(trait.COMMAND_OPENCLOSE, BASIC_DATA, {"openPercent": 0}, {}) await trt.execute(trait.COMMAND_OPEN_CLOSE, BASIC_DATA, {"openPercent": 0}, {})
await trt.execute( await trt.execute(
trait.COMMAND_OPENCLOSE_RELATIVE, BASIC_DATA, {"openRelativePercent": 0}, {} trait.COMMAND_OPEN_CLOSE_RELATIVE, BASIC_DATA, {"openRelativePercent": 0}, {}
) )
assert len(calls_set) == 1 assert len(calls_set) == 1
assert len(calls_close) == 1 assert len(calls_close) == 1
@ -3123,7 +3128,7 @@ async def test_openclose_cover_valve_unknown_state(
trt.query_attributes() trt.query_attributes()
calls = async_mock_service(hass, domain, open_service) calls = async_mock_service(hass, domain, open_service)
await trt.execute(trait.COMMAND_OPENCLOSE, BASIC_DATA, {"openPercent": 100}, {}) await trt.execute(trait.COMMAND_OPEN_CLOSE, BASIC_DATA, {"openPercent": 100}, {})
assert len(calls) == 1 assert len(calls) == 1
assert calls[0].data == {ATTR_ENTITY_ID: f"{domain}.bla"} assert calls[0].data == {ATTR_ENTITY_ID: f"{domain}.bla"}
@ -3177,7 +3182,7 @@ async def test_openclose_cover_valve_assumed_state(
assert trt.query_attributes() == {} assert trt.query_attributes() == {}
calls = async_mock_service(hass, domain, set_position_service) calls = async_mock_service(hass, domain, set_position_service)
await trt.execute(trait.COMMAND_OPENCLOSE, BASIC_DATA, {"openPercent": 40}, {}) await trt.execute(trait.COMMAND_OPEN_CLOSE, BASIC_DATA, {"openPercent": 40}, {})
assert len(calls) == 1 assert len(calls) == 1
assert calls[0].data == {ATTR_ENTITY_ID: f"{domain}.bla", cover.ATTR_POSITION: 40} assert calls[0].data == {ATTR_ENTITY_ID: f"{domain}.bla", cover.ATTR_POSITION: 40}
@ -3291,12 +3296,12 @@ async def test_openclose_cover_valve_no_position(
assert trt.query_attributes() == {"openPercent": 0} assert trt.query_attributes() == {"openPercent": 0}
calls = async_mock_service(hass, domain, close_service) calls = async_mock_service(hass, domain, close_service)
await trt.execute(trait.COMMAND_OPENCLOSE, BASIC_DATA, {"openPercent": 0}, {}) await trt.execute(trait.COMMAND_OPEN_CLOSE, BASIC_DATA, {"openPercent": 0}, {})
assert len(calls) == 1 assert len(calls) == 1
assert calls[0].data == {ATTR_ENTITY_ID: f"{domain}.bla"} assert calls[0].data == {ATTR_ENTITY_ID: f"{domain}.bla"}
calls = async_mock_service(hass, domain, open_service) calls = async_mock_service(hass, domain, open_service)
await trt.execute(trait.COMMAND_OPENCLOSE, BASIC_DATA, {"openPercent": 100}, {}) await trt.execute(trait.COMMAND_OPEN_CLOSE, BASIC_DATA, {"openPercent": 100}, {})
assert len(calls) == 1 assert len(calls) == 1
assert calls[0].data == {ATTR_ENTITY_ID: f"{domain}.bla"} assert calls[0].data == {ATTR_ENTITY_ID: f"{domain}.bla"}
@ -3304,14 +3309,14 @@ async def test_openclose_cover_valve_no_position(
SmartHomeError, match=r"Current position not know for relative command" SmartHomeError, match=r"Current position not know for relative command"
): ):
await trt.execute( await trt.execute(
trait.COMMAND_OPENCLOSE_RELATIVE, trait.COMMAND_OPEN_CLOSE_RELATIVE,
BASIC_DATA, BASIC_DATA,
{"openRelativePercent": 100}, {"openRelativePercent": 100},
{}, {},
) )
with pytest.raises(SmartHomeError, match=r"No support for partial open close"): with pytest.raises(SmartHomeError, match=r"No support for partial open close"):
await trt.execute(trait.COMMAND_OPENCLOSE, BASIC_DATA, {"openPercent": 50}, {}) await trt.execute(trait.COMMAND_OPEN_CLOSE, BASIC_DATA, {"openPercent": 50}, {})
@pytest.mark.parametrize( @pytest.mark.parametrize(
@ -3354,7 +3359,7 @@ async def test_openclose_cover_secure(hass: HomeAssistant, device_class) -> None
# No challenge data # No challenge data
with pytest.raises(error.ChallengeNeeded) as err: with pytest.raises(error.ChallengeNeeded) as err:
await trt.execute(trait.COMMAND_OPENCLOSE, PIN_DATA, {"openPercent": 50}, {}) await trt.execute(trait.COMMAND_OPEN_CLOSE, PIN_DATA, {"openPercent": 50}, {})
assert len(calls) == 0 assert len(calls) == 0
assert err.value.code == const.ERR_CHALLENGE_NEEDED assert err.value.code == const.ERR_CHALLENGE_NEEDED
assert err.value.challenge_type == const.CHALLENGE_PIN_NEEDED assert err.value.challenge_type == const.CHALLENGE_PIN_NEEDED
@ -3362,20 +3367,20 @@ async def test_openclose_cover_secure(hass: HomeAssistant, device_class) -> None
# invalid pin # invalid pin
with pytest.raises(error.ChallengeNeeded) as err: with pytest.raises(error.ChallengeNeeded) as err:
await trt.execute( await trt.execute(
trait.COMMAND_OPENCLOSE, PIN_DATA, {"openPercent": 50}, {"pin": "9999"} trait.COMMAND_OPEN_CLOSE, PIN_DATA, {"openPercent": 50}, {"pin": "9999"}
) )
assert len(calls) == 0 assert len(calls) == 0
assert err.value.code == const.ERR_CHALLENGE_NEEDED assert err.value.code == const.ERR_CHALLENGE_NEEDED
assert err.value.challenge_type == const.CHALLENGE_FAILED_PIN_NEEDED assert err.value.challenge_type == const.CHALLENGE_FAILED_PIN_NEEDED
await trt.execute( await trt.execute(
trait.COMMAND_OPENCLOSE, PIN_DATA, {"openPercent": 50}, {"pin": "1234"} trait.COMMAND_OPEN_CLOSE, PIN_DATA, {"openPercent": 50}, {"pin": "1234"}
) )
assert len(calls) == 1 assert len(calls) == 1
assert calls[0].data == {ATTR_ENTITY_ID: "cover.bla", cover.ATTR_POSITION: 50} assert calls[0].data == {ATTR_ENTITY_ID: "cover.bla", cover.ATTR_POSITION: 50}
# no challenge on close # no challenge on close
await trt.execute(trait.COMMAND_OPENCLOSE, PIN_DATA, {"openPercent": 0}, {}) await trt.execute(trait.COMMAND_OPEN_CLOSE, PIN_DATA, {"openPercent": 0}, {})
assert len(calls_close) == 1 assert len(calls_close) == 1
assert calls_close[0].data == {ATTR_ENTITY_ID: "cover.bla"} assert calls_close[0].data == {ATTR_ENTITY_ID: "cover.bla"}
@ -3699,7 +3704,7 @@ async def test_humidity_setting_sensor_data(
assert trt.query_attributes() == {} assert trt.query_attributes() == {}
with pytest.raises(helpers.SmartHomeError) as err: with pytest.raises(helpers.SmartHomeError) as err:
await trt.execute(trait.COMMAND_ONOFF, BASIC_DATA, {"on": False}, {}) await trt.execute(trait.COMMAND_ON_OFF, BASIC_DATA, {"on": False}, {})
assert err.value.code == const.ERR_NOT_SUPPORTED assert err.value.code == const.ERR_NOT_SUPPORTED