diff --git a/homeassistant/components/alexa/capabilities.py b/homeassistant/components/alexa/capabilities.py index 03ba353bb5b..6633cda8a97 100644 --- a/homeassistant/components/alexa/capabilities.py +++ b/homeassistant/components/alexa/capabilities.py @@ -29,6 +29,7 @@ from homeassistant.components.alarm_control_panel import ( CodeFormat, ) from homeassistant.components.climate import HVACMode +from homeassistant.components.lock import LockState from homeassistant.const import ( ATTR_CODE_FORMAT, ATTR_SUPPORTED_FEATURES, @@ -40,16 +41,12 @@ from homeassistant.const import ( STATE_ALARM_ARMED_HOME, STATE_ALARM_ARMED_NIGHT, STATE_IDLE, - STATE_LOCKED, - STATE_LOCKING, STATE_OFF, STATE_ON, STATE_PAUSED, STATE_PLAYING, STATE_UNAVAILABLE, STATE_UNKNOWN, - STATE_UNLOCKED, - STATE_UNLOCKING, UnitOfLength, UnitOfMass, UnitOfTemperature, @@ -500,10 +497,10 @@ class AlexaLockController(AlexaCapability): raise UnsupportedProperty(name) # If its unlocking its still locked and not unlocked yet - if self.entity.state in (STATE_UNLOCKING, STATE_LOCKED): + if self.entity.state in (LockState.UNLOCKING, LockState.LOCKED): return "LOCKED" # If its locking its still unlocked and not locked yet - if self.entity.state in (STATE_LOCKING, STATE_UNLOCKED): + if self.entity.state in (LockState.LOCKING, LockState.UNLOCKED): return "UNLOCKED" return "JAMMED" diff --git a/homeassistant/components/demo/lock.py b/homeassistant/components/demo/lock.py index c17e10edd85..1f25445af7f 100644 --- a/homeassistant/components/demo/lock.py +++ b/homeassistant/components/demo/lock.py @@ -5,17 +5,8 @@ from __future__ import annotations import asyncio from typing import Any -from homeassistant.components.lock import LockEntity, LockEntityFeature +from homeassistant.components.lock import LockEntity, LockEntityFeature, LockState from homeassistant.config_entries import ConfigEntry -from homeassistant.const import ( - STATE_JAMMED, - STATE_LOCKED, - STATE_LOCKING, - STATE_OPEN, - STATE_OPENING, - STATE_UNLOCKED, - STATE_UNLOCKING, -) from homeassistant.core import HomeAssistant from homeassistant.helpers.entity_platform import AddEntitiesCallback @@ -30,10 +21,10 @@ async def async_setup_entry( """Set up the Demo config entry.""" async_add_entities( [ - DemoLock("Front Door", STATE_LOCKED), - DemoLock("Kitchen Door", STATE_UNLOCKED), - DemoLock("Poorly Installed Door", STATE_UNLOCKED, False, True), - DemoLock("Openable Lock", STATE_LOCKED, True), + DemoLock("Front Door", LockState.LOCKED), + DemoLock("Kitchen Door", LockState.UNLOCKED), + DemoLock("Poorly Installed Door", LockState.UNLOCKED, False, True), + DemoLock("Openable Lock", LockState.LOCKED, True), ] ) @@ -61,56 +52,56 @@ class DemoLock(LockEntity): @property def is_locking(self) -> bool: """Return true if lock is locking.""" - return self._state == STATE_LOCKING + return self._state == LockState.LOCKING @property def is_unlocking(self) -> bool: """Return true if lock is unlocking.""" - return self._state == STATE_UNLOCKING + return self._state == LockState.UNLOCKING @property def is_jammed(self) -> bool: """Return true if lock is jammed.""" - return self._state == STATE_JAMMED + return self._state == LockState.JAMMED @property def is_locked(self) -> bool: """Return true if lock is locked.""" - return self._state == STATE_LOCKED + return self._state == LockState.LOCKED @property def is_open(self) -> bool: """Return true if lock is open.""" - return self._state == STATE_OPEN + return self._state == LockState.OPEN @property def is_opening(self) -> bool: """Return true if lock is opening.""" - return self._state == STATE_OPENING + return self._state == LockState.OPENING async def async_lock(self, **kwargs: Any) -> None: """Lock the device.""" - self._state = STATE_LOCKING + self._state = LockState.LOCKING self.async_write_ha_state() await asyncio.sleep(LOCK_UNLOCK_DELAY) if self._jam_on_operation: - self._state = STATE_JAMMED + self._state = LockState.JAMMED else: - self._state = STATE_LOCKED + self._state = LockState.LOCKED self.async_write_ha_state() async def async_unlock(self, **kwargs: Any) -> None: """Unlock the device.""" - self._state = STATE_UNLOCKING + self._state = LockState.UNLOCKING self.async_write_ha_state() await asyncio.sleep(LOCK_UNLOCK_DELAY) - self._state = STATE_UNLOCKED + self._state = LockState.UNLOCKED self.async_write_ha_state() async def async_open(self, **kwargs: Any) -> None: """Open the door latch.""" - self._state = STATE_OPENING + self._state = LockState.OPENING self.async_write_ha_state() await asyncio.sleep(LOCK_UNLOCK_DELAY) - self._state = STATE_OPEN + self._state = LockState.OPEN self.async_write_ha_state() diff --git a/homeassistant/components/google_assistant/trait.py b/homeassistant/components/google_assistant/trait.py index 145eb4b2935..95faf7c3321 100644 --- a/homeassistant/components/google_assistant/trait.py +++ b/homeassistant/components/google_assistant/trait.py @@ -40,7 +40,7 @@ from homeassistant.components.cover import CoverEntityFeature from homeassistant.components.fan import FanEntityFeature from homeassistant.components.humidifier import HumidifierEntityFeature from homeassistant.components.light import LightEntityFeature -from homeassistant.components.lock import STATE_JAMMED, STATE_UNLOCKING +from homeassistant.components.lock import LockState from homeassistant.components.media_player import MediaPlayerEntityFeature, MediaType from homeassistant.components.vacuum import VacuumEntityFeature from homeassistant.components.valve import ValveEntityFeature @@ -71,7 +71,6 @@ from homeassistant.const import ( STATE_ALARM_PENDING, STATE_ALARM_TRIGGERED, STATE_IDLE, - STATE_LOCKED, STATE_OFF, STATE_ON, STATE_PAUSED, @@ -1524,11 +1523,11 @@ class LockUnlockTrait(_Trait): def query_attributes(self) -> dict[str, Any]: """Return LockUnlock query attributes.""" - if self.state.state == STATE_JAMMED: + if self.state.state == LockState.JAMMED: return {"isJammed": True} # If its unlocking its not yet unlocked so we consider is locked - return {"isLocked": self.state.state in (STATE_UNLOCKING, STATE_LOCKED)} + return {"isLocked": self.state.state in (LockState.UNLOCKING, LockState.LOCKED)} async def execute(self, command, data, params, challenge): """Execute an LockUnlock command.""" diff --git a/homeassistant/components/group/lock.py b/homeassistant/components/group/lock.py index 73e8c30bfde..e22e1ecd85c 100644 --- a/homeassistant/components/group/lock.py +++ b/homeassistant/components/group/lock.py @@ -12,6 +12,7 @@ from homeassistant.components.lock import ( PLATFORM_SCHEMA as LOCK_PLATFORM_SCHEMA, LockEntity, LockEntityFeature, + LockState, ) from homeassistant.config_entries import ConfigEntry from homeassistant.const import ( @@ -22,14 +23,8 @@ from homeassistant.const import ( SERVICE_LOCK, SERVICE_OPEN, SERVICE_UNLOCK, - STATE_JAMMED, - STATE_LOCKED, - STATE_LOCKING, - STATE_OPEN, - STATE_OPENING, STATE_UNAVAILABLE, STATE_UNKNOWN, - STATE_UNLOCKING, ) from homeassistant.core import HomeAssistant, callback from homeassistant.helpers import config_validation as cv, entity_registry as er @@ -183,11 +178,11 @@ class LockGroup(GroupEntity, LockEntity): self._attr_is_locked = None else: # Set attributes based on member states and let the lock entity sort out the correct state - self._attr_is_jammed = STATE_JAMMED in states - self._attr_is_locking = STATE_LOCKING in states - self._attr_is_opening = STATE_OPENING in states - self._attr_is_open = STATE_OPEN in states - self._attr_is_unlocking = STATE_UNLOCKING in states - self._attr_is_locked = all(state == STATE_LOCKED for state in states) + self._attr_is_jammed = LockState.JAMMED in states + self._attr_is_locking = LockState.LOCKING in states + self._attr_is_opening = LockState.OPENING in states + self._attr_is_open = LockState.OPEN in states + self._attr_is_unlocking = LockState.UNLOCKING in states + self._attr_is_locked = all(state == LockState.LOCKED for state in states) self._attr_available = any(state != STATE_UNAVAILABLE for state in states) diff --git a/homeassistant/components/group/registry.py b/homeassistant/components/group/registry.py index 96fa8721271..e0a74d32f44 100644 --- a/homeassistant/components/group/registry.py +++ b/homeassistant/components/group/registry.py @@ -9,6 +9,7 @@ from dataclasses import dataclass from typing import Protocol from homeassistant.components.climate import HVACMode +from homeassistant.components.lock import LockState from homeassistant.components.vacuum import STATE_CLEANING, STATE_ERROR, STATE_RETURNING from homeassistant.components.water_heater import ( STATE_ECO, @@ -28,19 +29,14 @@ from homeassistant.const import ( STATE_CLOSED, STATE_HOME, STATE_IDLE, - STATE_LOCKED, - STATE_LOCKING, STATE_NOT_HOME, STATE_OFF, STATE_OK, STATE_ON, STATE_OPEN, - STATE_OPENING, STATE_PAUSED, STATE_PLAYING, STATE_PROBLEM, - STATE_UNLOCKED, - STATE_UNLOCKING, Platform, ) from homeassistant.core import HomeAssistant, callback @@ -90,14 +86,14 @@ ON_OFF_STATES: dict[Platform | str, tuple[set[str], str, str]] = { Platform.DEVICE_TRACKER: ({STATE_HOME}, STATE_HOME, STATE_NOT_HOME), Platform.LOCK: ( { - STATE_LOCKING, - STATE_OPEN, - STATE_OPENING, - STATE_UNLOCKED, - STATE_UNLOCKING, + LockState.LOCKING, + LockState.OPEN, + LockState.OPENING, + LockState.UNLOCKED, + LockState.UNLOCKING, }, - STATE_UNLOCKED, - STATE_LOCKED, + LockState.UNLOCKED, + LockState.LOCKED, ), Platform.MEDIA_PLAYER: ( { diff --git a/homeassistant/components/homekit/type_locks.py b/homeassistant/components/homekit/type_locks.py index 52dc71078d0..70570a8fca5 100644 --- a/homeassistant/components/homekit/type_locks.py +++ b/homeassistant/components/homekit/type_locks.py @@ -5,14 +5,7 @@ from typing import Any from pyhap.const import CATEGORY_DOOR_LOCK -from homeassistant.components.lock import ( - DOMAIN as LOCK_DOMAIN, - STATE_JAMMED, - STATE_LOCKED, - STATE_LOCKING, - STATE_UNLOCKED, - STATE_UNLOCKING, -) +from homeassistant.components.lock import DOMAIN as LOCK_DOMAIN, LockState from homeassistant.const import ATTR_CODE, ATTR_ENTITY_ID, STATE_UNKNOWN from homeassistant.core import State, callback @@ -22,35 +15,40 @@ from .const import CHAR_LOCK_CURRENT_STATE, CHAR_LOCK_TARGET_STATE, SERV_LOCK _LOGGER = logging.getLogger(__name__) HASS_TO_HOMEKIT_CURRENT = { - STATE_UNLOCKED: 0, - STATE_UNLOCKING: 1, - STATE_LOCKING: 0, - STATE_LOCKED: 1, - STATE_JAMMED: 2, + LockState.UNLOCKED.value: 0, + LockState.UNLOCKING.value: 1, + LockState.LOCKING.value: 0, + LockState.LOCKED.value: 1, + LockState.JAMMED.value: 2, STATE_UNKNOWN: 3, } HASS_TO_HOMEKIT_TARGET = { - STATE_UNLOCKED: 0, - STATE_UNLOCKING: 0, - STATE_LOCKING: 1, - STATE_LOCKED: 1, + LockState.UNLOCKED.value: 0, + LockState.UNLOCKING.value: 0, + LockState.LOCKING.value: 1, + LockState.LOCKED.value: 1, } -VALID_TARGET_STATES = {STATE_LOCKING, STATE_UNLOCKING, STATE_LOCKED, STATE_UNLOCKED} +VALID_TARGET_STATES = { + LockState.LOCKING.value, + LockState.UNLOCKING.value, + LockState.LOCKED.value, + LockState.UNLOCKED.value, +} HOMEKIT_TO_HASS = { - 0: STATE_UNLOCKED, - 1: STATE_LOCKED, - 2: STATE_JAMMED, + 0: LockState.UNLOCKED.value, + 1: LockState.LOCKED.value, + 2: LockState.JAMMED.value, 3: STATE_UNKNOWN, } STATE_TO_SERVICE = { - STATE_LOCKING: "unlock", - STATE_LOCKED: "lock", - STATE_UNLOCKING: "lock", - STATE_UNLOCKED: "unlock", + LockState.LOCKING.value: "unlock", + LockState.LOCKED.value: "lock", + LockState.UNLOCKING.value: "lock", + LockState.UNLOCKED.value: "unlock", } @@ -74,7 +72,7 @@ class Lock(HomeAccessory): ) self.char_target_state = serv_lock_mechanism.configure_char( CHAR_LOCK_TARGET_STATE, - value=HASS_TO_HOMEKIT_CURRENT[STATE_LOCKED], + value=HASS_TO_HOMEKIT_CURRENT[LockState.LOCKED.value], setter_callback=self.set_state, ) self.async_update_state(state) diff --git a/homeassistant/components/homekit_controller/lock.py b/homeassistant/components/homekit_controller/lock.py index 8e1bcd424d4..98974c4a514 100644 --- a/homeassistant/components/homekit_controller/lock.py +++ b/homeassistant/components/homekit_controller/lock.py @@ -7,15 +7,9 @@ from typing import Any from aiohomekit.model.characteristics import CharacteristicsTypes from aiohomekit.model.services import Service, ServicesTypes -from homeassistant.components.lock import STATE_JAMMED, LockEntity +from homeassistant.components.lock import LockEntity, LockState from homeassistant.config_entries import ConfigEntry -from homeassistant.const import ( - ATTR_BATTERY_LEVEL, - STATE_LOCKED, - STATE_UNKNOWN, - STATE_UNLOCKED, - Platform, -) +from homeassistant.const import ATTR_BATTERY_LEVEL, STATE_UNKNOWN, Platform from homeassistant.core import HomeAssistant, callback from homeassistant.helpers.entity_platform import AddEntitiesCallback @@ -24,13 +18,13 @@ from .connection import HKDevice from .entity import HomeKitEntity CURRENT_STATE_MAP = { - 0: STATE_UNLOCKED, - 1: STATE_LOCKED, - 2: STATE_JAMMED, + 0: LockState.UNLOCKED, + 1: LockState.LOCKED, + 2: LockState.JAMMED, 3: STATE_UNKNOWN, } -TARGET_STATE_MAP = {STATE_UNLOCKED: 0, STATE_LOCKED: 1} +TARGET_STATE_MAP = {LockState.UNLOCKED: 0, LockState.LOCKED: 1} REVERSED_TARGET_STATE_MAP = {v: k for k, v in TARGET_STATE_MAP.items()} @@ -76,7 +70,7 @@ class HomeKitLock(HomeKitEntity, LockEntity): value = self.service.value(CharacteristicsTypes.LOCK_MECHANISM_CURRENT_STATE) if CURRENT_STATE_MAP[value] == STATE_UNKNOWN: return None - return CURRENT_STATE_MAP[value] == STATE_LOCKED + return CURRENT_STATE_MAP[value] == LockState.LOCKED @property def is_locking(self) -> bool: @@ -88,8 +82,8 @@ class HomeKitLock(HomeKitEntity, LockEntity): CharacteristicsTypes.LOCK_MECHANISM_TARGET_STATE ) return ( - CURRENT_STATE_MAP[current_value] == STATE_UNLOCKED - and REVERSED_TARGET_STATE_MAP.get(target_value) == STATE_LOCKED + CURRENT_STATE_MAP[current_value] == LockState.UNLOCKED + and REVERSED_TARGET_STATE_MAP.get(target_value) == LockState.LOCKED ) @property @@ -102,25 +96,25 @@ class HomeKitLock(HomeKitEntity, LockEntity): CharacteristicsTypes.LOCK_MECHANISM_TARGET_STATE ) return ( - CURRENT_STATE_MAP[current_value] == STATE_LOCKED - and REVERSED_TARGET_STATE_MAP.get(target_value) == STATE_UNLOCKED + CURRENT_STATE_MAP[current_value] == LockState.LOCKED + and REVERSED_TARGET_STATE_MAP.get(target_value) == LockState.UNLOCKED ) @property def is_jammed(self) -> bool: """Return true if device is jammed.""" value = self.service.value(CharacteristicsTypes.LOCK_MECHANISM_CURRENT_STATE) - return CURRENT_STATE_MAP[value] == STATE_JAMMED + return CURRENT_STATE_MAP[value] == LockState.JAMMED async def async_lock(self, **kwargs: Any) -> None: """Lock the device.""" - await self._set_lock_state(STATE_LOCKED) + await self._set_lock_state(LockState.LOCKED) async def async_unlock(self, **kwargs: Any) -> None: """Unlock the device.""" - await self._set_lock_state(STATE_UNLOCKED) + await self._set_lock_state(LockState.UNLOCKED) - async def _set_lock_state(self, state: str) -> None: + async def _set_lock_state(self, state: LockState) -> None: """Send state command.""" await self.async_put_characteristics( {CharacteristicsTypes.LOCK_MECHANISM_TARGET_STATE: TARGET_STATE_MAP[state]} diff --git a/homeassistant/components/isy994/const.py b/homeassistant/components/isy994/const.py index 57b30c88075..b43385a0e5d 100644 --- a/homeassistant/components/isy994/const.py +++ b/homeassistant/components/isy994/const.py @@ -15,6 +15,7 @@ from homeassistant.components.climate import ( HVACAction, HVACMode, ) +from homeassistant.components.lock import LockState from homeassistant.const import ( CONCENTRATION_MICROGRAMS_PER_CUBIC_METER, CONCENTRATION_PARTS_PER_MILLION, @@ -29,14 +30,12 @@ from homeassistant.const import ( SIGNAL_STRENGTH_DECIBELS_MILLIWATT, STATE_CLOSED, STATE_CLOSING, - STATE_LOCKED, STATE_OFF, STATE_ON, STATE_OPEN, STATE_OPENING, STATE_PROBLEM, STATE_UNKNOWN, - STATE_UNLOCKED, UV_INDEX, Platform, UnitOfApparentPower, @@ -451,8 +450,8 @@ UOM_FRIENDLY_NAME = { UOM_TO_STATES = { "11": { # Deadbolt Status - 0: STATE_UNLOCKED, - 100: STATE_LOCKED, + 0: LockState.UNLOCKED, + 100: LockState.LOCKED, 101: STATE_UNKNOWN, 102: STATE_PROBLEM, }, diff --git a/homeassistant/components/kitchen_sink/lock.py b/homeassistant/components/kitchen_sink/lock.py index 9b8093c2f0b..80ecc57d0d9 100644 --- a/homeassistant/components/kitchen_sink/lock.py +++ b/homeassistant/components/kitchen_sink/lock.py @@ -4,9 +4,8 @@ from __future__ import annotations from typing import Any -from homeassistant.components.lock import LockEntity, LockEntityFeature +from homeassistant.components.lock import LockEntity, LockEntityFeature, LockState from homeassistant.config_entries import ConfigEntry -from homeassistant.const import STATE_LOCKED, STATE_OPEN, STATE_UNLOCKED from homeassistant.core import HomeAssistant from homeassistant.helpers.entity_platform import AddEntitiesCallback from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType @@ -24,24 +23,24 @@ async def async_setup_platform( DemoLock( "kitchen_sink_lock_001", "Openable lock", - STATE_LOCKED, + LockState.LOCKED, LockEntityFeature.OPEN, ), DemoLock( "kitchen_sink_lock_002", "Another openable lock", - STATE_UNLOCKED, + LockState.UNLOCKED, LockEntityFeature.OPEN, ), DemoLock( "kitchen_sink_lock_003", "Basic lock", - STATE_LOCKED, + LockState.LOCKED, ), DemoLock( "kitchen_sink_lock_004", "Another basic lock", - STATE_UNLOCKED, + LockState.UNLOCKED, ), ] ) @@ -77,19 +76,19 @@ class DemoLock(LockEntity): @property def is_locked(self) -> bool: """Return true if lock is locked.""" - return self._state == STATE_LOCKED + return self._state == LockState.LOCKED @property def is_open(self) -> bool: """Return true if lock is open.""" - return self._state == STATE_OPEN + return self._state == LockState.OPEN async def async_lock(self, **kwargs: Any) -> None: """Lock the device.""" self._attr_is_locking = True self.async_write_ha_state() self._attr_is_locking = False - self._state = STATE_LOCKED + self._state = LockState.LOCKED self.async_write_ha_state() async def async_unlock(self, **kwargs: Any) -> None: @@ -97,10 +96,10 @@ class DemoLock(LockEntity): self._attr_is_unlocking = True self.async_write_ha_state() self._attr_is_unlocking = False - self._state = STATE_UNLOCKED + self._state = LockState.UNLOCKED self.async_write_ha_state() async def async_open(self, **kwargs: Any) -> None: """Open the door latch.""" - self._state = STATE_OPEN + self._state = LockState.OPEN self.async_write_ha_state() diff --git a/homeassistant/components/kiwi/lock.py b/homeassistant/components/kiwi/lock.py index fb4272dfa63..887747d4ca4 100644 --- a/homeassistant/components/kiwi/lock.py +++ b/homeassistant/components/kiwi/lock.py @@ -11,6 +11,7 @@ import voluptuous as vol from homeassistant.components.lock import ( PLATFORM_SCHEMA as LOCK_PLATFORM_SCHEMA, LockEntity, + LockState, ) from homeassistant.const import ( ATTR_ID, @@ -18,8 +19,6 @@ from homeassistant.const import ( ATTR_LONGITUDE, CONF_PASSWORD, CONF_USERNAME, - STATE_LOCKED, - STATE_UNLOCKED, ) from homeassistant.core import HomeAssistant, callback import homeassistant.helpers.config_validation as cv @@ -68,7 +67,7 @@ class KiwiLock(LockEntity): self._sensor = kiwi_lock self._client = client self.lock_id = kiwi_lock["sensor_id"] - self._state = STATE_LOCKED + self._state = LockState.LOCKED address = kiwi_lock.get("address") address.update( @@ -96,7 +95,7 @@ class KiwiLock(LockEntity): @property def is_locked(self) -> bool: """Return true if lock is locked.""" - return self._state == STATE_LOCKED + return self._state == LockState.LOCKED @property def extra_state_attributes(self) -> dict[str, Any]: @@ -106,7 +105,7 @@ class KiwiLock(LockEntity): @callback def clear_unlock_state(self, _): """Clear unlock state automatically.""" - self._state = STATE_LOCKED + self._state = LockState.LOCKED self.async_write_ha_state() def unlock(self, **kwargs: Any) -> None: @@ -117,7 +116,7 @@ class KiwiLock(LockEntity): except KiwiException: _LOGGER.error("Failed to open door") else: - self._state = STATE_UNLOCKED + self._state = LockState.UNLOCKED self.hass.add_job( async_call_later, self.hass, diff --git a/homeassistant/components/lock/__init__.py b/homeassistant/components/lock/__init__.py index d9123497696..d70c6383ce0 100644 --- a/homeassistant/components/lock/__init__.py +++ b/homeassistant/components/lock/__init__.py @@ -13,19 +13,19 @@ from typing import TYPE_CHECKING, Any, final import voluptuous as vol from homeassistant.config_entries import ConfigEntry -from homeassistant.const import ( +from homeassistant.const import ( # noqa: F401 + _DEPRECATED_STATE_JAMMED, + _DEPRECATED_STATE_LOCKED, + _DEPRECATED_STATE_LOCKING, + _DEPRECATED_STATE_UNLOCKED, + _DEPRECATED_STATE_UNLOCKING, ATTR_CODE, ATTR_CODE_FORMAT, SERVICE_LOCK, SERVICE_OPEN, SERVICE_UNLOCK, - STATE_JAMMED, - STATE_LOCKED, - STATE_LOCKING, STATE_OPEN, STATE_OPENING, - STATE_UNLOCKED, - STATE_UNLOCKING, ) from homeassistant.core import HomeAssistant, callback from homeassistant.exceptions import ServiceValidationError @@ -41,7 +41,7 @@ from homeassistant.helpers.entity_component import EntityComponent from homeassistant.helpers.typing import ConfigType, StateType from homeassistant.util.hass_dict import HassKey -from .const import DOMAIN +from .const import DOMAIN, LockState _LOGGER = logging.getLogger(__name__) @@ -274,18 +274,18 @@ class LockEntity(Entity, cached_properties=CACHED_PROPERTIES_WITH_ATTR_): def state(self) -> str | None: """Return the state.""" if self.is_jammed: - return STATE_JAMMED + return LockState.JAMMED if self.is_opening: - return STATE_OPENING + return LockState.OPENING if self.is_locking: - return STATE_LOCKING + return LockState.LOCKING if self.is_open: - return STATE_OPEN + return LockState.OPEN if self.is_unlocking: - return STATE_UNLOCKING + return LockState.UNLOCKING if (locked := self.is_locked) is None: return None - return STATE_LOCKED if locked else STATE_UNLOCKED + return LockState.LOCKED if locked else LockState.UNLOCKED @cached_property def supported_features(self) -> LockEntityFeature: diff --git a/homeassistant/components/lock/const.py b/homeassistant/components/lock/const.py index 1370a26ab36..7a06bc12b05 100644 --- a/homeassistant/components/lock/const.py +++ b/homeassistant/components/lock/const.py @@ -1,3 +1,17 @@ """Constants for the lock entity platform.""" +from enum import StrEnum + DOMAIN = "lock" + + +class LockState(StrEnum): + """State of lock entities.""" + + JAMMED = "jammed" + OPENING = "opening" + LOCKING = "locking" + OPEN = "open" + UNLOCKING = "unlocking" + LOCKED = "locked" + UNLOCKED = "unlocked" diff --git a/homeassistant/components/lock/device_condition.py b/homeassistant/components/lock/device_condition.py index ec6373c889f..c104abd82a4 100644 --- a/homeassistant/components/lock/device_condition.py +++ b/homeassistant/components/lock/device_condition.py @@ -11,13 +11,6 @@ from homeassistant.const import ( CONF_DOMAIN, CONF_ENTITY_ID, CONF_TYPE, - STATE_JAMMED, - STATE_LOCKED, - STATE_LOCKING, - STATE_OPEN, - STATE_OPENING, - STATE_UNLOCKED, - STATE_UNLOCKING, ) from homeassistant.core import HomeAssistant, callback from homeassistant.helpers import ( @@ -28,7 +21,7 @@ from homeassistant.helpers import ( from homeassistant.helpers.config_validation import DEVICE_CONDITION_BASE_SCHEMA from homeassistant.helpers.typing import ConfigType, TemplateVarsType -from . import DOMAIN +from . import DOMAIN, LockState # mypy: disallow-any-generics @@ -81,19 +74,19 @@ def async_condition_from_config( ) -> condition.ConditionCheckerType: """Create a function to test a device condition.""" if config[CONF_TYPE] == "is_jammed": - state = STATE_JAMMED + state = LockState.JAMMED elif config[CONF_TYPE] == "is_opening": - state = STATE_OPENING + state = LockState.OPENING elif config[CONF_TYPE] == "is_locking": - state = STATE_LOCKING + state = LockState.LOCKING elif config[CONF_TYPE] == "is_open": - state = STATE_OPEN + state = LockState.OPEN elif config[CONF_TYPE] == "is_unlocking": - state = STATE_UNLOCKING + state = LockState.UNLOCKING elif config[CONF_TYPE] == "is_locked": - state = STATE_LOCKED + state = LockState.LOCKED else: - state = STATE_UNLOCKED + state = LockState.UNLOCKED registry = er.async_get(hass) entity_id = er.async_resolve_entity_id(registry, config[ATTR_ENTITY_ID]) diff --git a/homeassistant/components/lock/device_trigger.py b/homeassistant/components/lock/device_trigger.py index 336fe127ca6..06e4e5b6431 100644 --- a/homeassistant/components/lock/device_trigger.py +++ b/homeassistant/components/lock/device_trigger.py @@ -13,20 +13,13 @@ from homeassistant.const import ( CONF_FOR, CONF_PLATFORM, CONF_TYPE, - STATE_JAMMED, - STATE_LOCKED, - STATE_LOCKING, - STATE_OPEN, - STATE_OPENING, - STATE_UNLOCKED, - STATE_UNLOCKING, ) from homeassistant.core import CALLBACK_TYPE, HomeAssistant from homeassistant.helpers import config_validation as cv, entity_registry as er from homeassistant.helpers.trigger import TriggerActionType, TriggerInfo from homeassistant.helpers.typing import ConfigType -from . import DOMAIN +from . import DOMAIN, LockState TRIGGER_TYPES = { "jammed", @@ -93,19 +86,19 @@ async def async_attach_trigger( ) -> CALLBACK_TYPE: """Attach a trigger.""" if config[CONF_TYPE] == "jammed": - to_state = STATE_JAMMED + to_state = LockState.JAMMED elif config[CONF_TYPE] == "opening": - to_state = STATE_OPENING + to_state = LockState.OPENING elif config[CONF_TYPE] == "locking": - to_state = STATE_LOCKING + to_state = LockState.LOCKING elif config[CONF_TYPE] == "open": - to_state = STATE_OPEN + to_state = LockState.OPEN elif config[CONF_TYPE] == "unlocking": - to_state = STATE_UNLOCKING + to_state = LockState.UNLOCKING elif config[CONF_TYPE] == "locked": - to_state = STATE_LOCKED + to_state = LockState.LOCKED else: - to_state = STATE_UNLOCKED + to_state = LockState.UNLOCKED state_config = { CONF_PLATFORM: "state", diff --git a/homeassistant/components/lock/reproduce_state.py b/homeassistant/components/lock/reproduce_state.py index 5fc3345c1f6..252528c9985 100644 --- a/homeassistant/components/lock/reproduce_state.py +++ b/homeassistant/components/lock/reproduce_state.py @@ -12,26 +12,20 @@ from homeassistant.const import ( SERVICE_LOCK, SERVICE_OPEN, SERVICE_UNLOCK, - STATE_LOCKED, - STATE_LOCKING, - STATE_OPEN, - STATE_OPENING, - STATE_UNLOCKED, - STATE_UNLOCKING, ) from homeassistant.core import Context, HomeAssistant, State -from . import DOMAIN +from . import DOMAIN, LockState _LOGGER = logging.getLogger(__name__) VALID_STATES = { - STATE_LOCKED, - STATE_LOCKING, - STATE_OPEN, - STATE_OPENING, - STATE_UNLOCKED, - STATE_UNLOCKING, + LockState.LOCKED, + LockState.LOCKING, + LockState.OPEN, + LockState.OPENING, + LockState.UNLOCKED, + LockState.UNLOCKING, } @@ -59,11 +53,11 @@ async def _async_reproduce_state( service_data = {ATTR_ENTITY_ID: state.entity_id} - if state.state in {STATE_LOCKED, STATE_LOCKING}: + if state.state in {LockState.LOCKED, LockState.LOCKING}: service = SERVICE_LOCK - elif state.state in {STATE_UNLOCKED, STATE_UNLOCKING}: + elif state.state in {LockState.UNLOCKED, LockState.UNLOCKING}: service = SERVICE_UNLOCK - elif state.state in {STATE_OPEN, STATE_OPENING}: + elif state.state in {LockState.OPEN, LockState.OPENING}: service = SERVICE_OPEN await hass.services.async_call( diff --git a/homeassistant/components/surepetcare/lock.py b/homeassistant/components/surepetcare/lock.py index cd79e06c5c3..f960400bcbc 100644 --- a/homeassistant/components/surepetcare/lock.py +++ b/homeassistant/components/surepetcare/lock.py @@ -5,11 +5,10 @@ from __future__ import annotations from typing import Any from surepy.entities import SurepyEntity -from surepy.enums import EntityType, LockState +from surepy.enums import EntityType, LockState as SurepyLockState -from homeassistant.components.lock import LockEntity +from homeassistant.components.lock import LockEntity, LockState from homeassistant.config_entries import ConfigEntry -from homeassistant.const import STATE_LOCKED, STATE_UNLOCKED from homeassistant.core import HomeAssistant, callback from homeassistant.helpers.entity_platform import AddEntitiesCallback @@ -30,9 +29,9 @@ async def async_setup_entry( for surepy_entity in coordinator.data.values() if surepy_entity.type in [EntityType.CAT_FLAP, EntityType.PET_FLAP] for lock_state in ( - LockState.LOCKED_IN, - LockState.LOCKED_OUT, - LockState.LOCKED_ALL, + SurepyLockState.LOCKED_IN, + SurepyLockState.LOCKED_OUT, + SurepyLockState.LOCKED_ALL, ) ) @@ -44,7 +43,7 @@ class SurePetcareLock(SurePetcareEntity, LockEntity): self, surepetcare_id: int, coordinator: SurePetcareDataCoordinator, - lock_state: LockState, + lock_state: SurepyLockState, ) -> None: """Initialize a Sure Petcare lock.""" self._lock_state = lock_state.name.lower() @@ -66,14 +65,14 @@ class SurePetcareLock(SurePetcareEntity, LockEntity): status = surepy_entity.raw_data()["status"] self._attr_is_locked = ( - LockState(status["locking"]["mode"]).name.lower() == self._lock_state + SurepyLockState(status["locking"]["mode"]).name.lower() == self._lock_state ) self._available = bool(status.get("online")) async def async_lock(self, **kwargs: Any) -> None: """Lock the lock.""" - if self.state != STATE_UNLOCKED: + if self.state != LockState.UNLOCKED: return self._attr_is_locking = True self.async_write_ha_state() @@ -87,7 +86,7 @@ class SurePetcareLock(SurePetcareEntity, LockEntity): async def async_unlock(self, **kwargs: Any) -> None: """Unlock the lock.""" - if self.state != STATE_LOCKED: + if self.state != LockState.LOCKED: return self._attr_is_unlocking = True self.async_write_ha_state() diff --git a/homeassistant/components/template/lock.py b/homeassistant/components/template/lock.py index 5c0b67a23dc..6ea8aff4c1a 100644 --- a/homeassistant/components/template/lock.py +++ b/homeassistant/components/template/lock.py @@ -8,10 +8,8 @@ import voluptuous as vol from homeassistant.components.lock import ( PLATFORM_SCHEMA as LOCK_PLATFORM_SCHEMA, - STATE_JAMMED, - STATE_LOCKING, - STATE_UNLOCKING, LockEntity, + LockState, ) from homeassistant.const import ( ATTR_CODE, @@ -19,9 +17,7 @@ from homeassistant.const import ( CONF_OPTIMISTIC, CONF_UNIQUE_ID, CONF_VALUE_TEMPLATE, - STATE_LOCKED, STATE_ON, - STATE_UNLOCKED, ) from homeassistant.core import HomeAssistant, callback from homeassistant.exceptions import ServiceValidationError, TemplateError @@ -102,22 +98,22 @@ class TemplateLock(TemplateEntity, LockEntity): @property def is_locked(self) -> bool: """Return true if lock is locked.""" - return self._state in ("true", STATE_ON, STATE_LOCKED) + return self._state in ("true", STATE_ON, LockState.LOCKED) @property def is_jammed(self) -> bool: """Return true if lock is jammed.""" - return self._state == STATE_JAMMED + return self._state == LockState.JAMMED @property def is_unlocking(self) -> bool: """Return true if lock is unlocking.""" - return self._state == STATE_UNLOCKING + return self._state == LockState.UNLOCKING @property def is_locking(self) -> bool: """Return true if lock is locking.""" - return self._state == STATE_LOCKING + return self._state == LockState.LOCKING @callback def _update_state(self, result): @@ -128,7 +124,7 @@ class TemplateLock(TemplateEntity, LockEntity): return if isinstance(result, bool): - self._state = STATE_LOCKED if result else STATE_UNLOCKED + self._state = LockState.LOCKED if result else LockState.UNLOCKED return if isinstance(result, str): diff --git a/homeassistant/components/verisure/lock.py b/homeassistant/components/verisure/lock.py index 5c56fc0df2c..87f5c53880e 100644 --- a/homeassistant/components/verisure/lock.py +++ b/homeassistant/components/verisure/lock.py @@ -7,9 +7,9 @@ from typing import Any from verisure import Error as VerisureError -from homeassistant.components.lock import LockEntity +from homeassistant.components.lock import LockEntity, LockState from homeassistant.config_entries import ConfigEntry -from homeassistant.const import ATTR_CODE, STATE_LOCKED, STATE_UNLOCKED +from homeassistant.const import ATTR_CODE from homeassistant.core import HomeAssistant from homeassistant.helpers.device_registry import DeviceInfo from homeassistant.helpers.entity_platform import ( @@ -130,19 +130,19 @@ class VerisureDoorlock(CoordinatorEntity[VerisureDataUpdateCoordinator], LockEnt """Send unlock command.""" code = kwargs.get(ATTR_CODE) if code: - await self.async_set_lock_state(code, STATE_UNLOCKED) + await self.async_set_lock_state(code, LockState.UNLOCKED) async def async_lock(self, **kwargs: Any) -> None: """Send lock command.""" code = kwargs.get(ATTR_CODE) if code: - await self.async_set_lock_state(code, STATE_LOCKED) + await self.async_set_lock_state(code, LockState.LOCKED) - async def async_set_lock_state(self, code: str, state: str) -> None: + async def async_set_lock_state(self, code: str, state: LockState) -> None: """Send set lock state command.""" command = ( self.coordinator.verisure.door_lock(self.serial_number, code) - if state == STATE_LOCKED + if state == LockState.LOCKED else self.coordinator.verisure.door_unlock(self.serial_number, code) ) lock_request = await self.hass.async_add_executor_job( @@ -151,7 +151,7 @@ class VerisureDoorlock(CoordinatorEntity[VerisureDataUpdateCoordinator], LockEnt ) LOGGER.debug("Verisure doorlock %s", state) transaction_id = lock_request.get("data", {}).get(command["operationName"]) - target_state = "LOCKED" if state == STATE_LOCKED else "UNLOCKED" + target_state = "LOCKED" if state == LockState.LOCKED else "UNLOCKED" lock_status = None attempts = 0 while lock_status != "OK": diff --git a/homeassistant/components/xiaomi_aqara/lock.py b/homeassistant/components/xiaomi_aqara/lock.py index f64f6ae527a..5e538f25699 100644 --- a/homeassistant/components/xiaomi_aqara/lock.py +++ b/homeassistant/components/xiaomi_aqara/lock.py @@ -2,9 +2,8 @@ from __future__ import annotations -from homeassistant.components.lock import LockEntity +from homeassistant.components.lock import LockEntity, LockState from homeassistant.config_entries import ConfigEntry -from homeassistant.const import STATE_LOCKED, STATE_UNLOCKED from homeassistant.core import HomeAssistant, callback from homeassistant.helpers.entity_platform import AddEntitiesCallback from homeassistant.helpers.event import async_call_later @@ -50,7 +49,7 @@ class XiaomiAqaraLock(LockEntity, XiaomiDevice): def is_locked(self) -> bool | None: """Return true if lock is locked.""" if self._state is not None: - return self._state == STATE_LOCKED + return self._state == LockState.LOCKED return None @property @@ -66,7 +65,7 @@ class XiaomiAqaraLock(LockEntity, XiaomiDevice): @callback def clear_unlock_state(self, _): """Clear unlock state automatically.""" - self._state = STATE_LOCKED + self._state = LockState.LOCKED self.async_write_ha_state() def parse_data(self, data, raw_data): @@ -79,7 +78,7 @@ class XiaomiAqaraLock(LockEntity, XiaomiDevice): if (value := data.get(key)) is not None: self._changed_by = int(value) self._verified_wrong_times = 0 - self._state = STATE_UNLOCKED + self._state = LockState.UNLOCKED async_call_later( self.hass, UNLOCK_MAINTAIN_TIME, self.clear_unlock_state ) diff --git a/homeassistant/components/yale_smart_alarm/lock.py b/homeassistant/components/yale_smart_alarm/lock.py index 65913dbb3bd..243299658ed 100644 --- a/homeassistant/components/yale_smart_alarm/lock.py +++ b/homeassistant/components/yale_smart_alarm/lock.py @@ -6,12 +6,7 @@ from typing import Any from yalesmartalarmclient import YaleLock, YaleLockState -from homeassistant.components.lock import ( - STATE_LOCKED, - STATE_OPEN, - STATE_UNLOCKED, - LockEntity, -) +from homeassistant.components.lock import LockEntity, LockState from homeassistant.const import ATTR_CODE from homeassistant.core import HomeAssistant from homeassistant.exceptions import HomeAssistantError, ServiceValidationError @@ -28,9 +23,9 @@ from .coordinator import YaleDataUpdateCoordinator from .entity import YaleLockEntity LOCK_STATE_MAP = { - YaleLockState.LOCKED: STATE_LOCKED, - YaleLockState.UNLOCKED: STATE_UNLOCKED, - YaleLockState.DOOR_OPEN: STATE_OPEN, + YaleLockState.LOCKED: LockState.LOCKED, + YaleLockState.UNLOCKED: LockState.UNLOCKED, + YaleLockState.DOOR_OPEN: LockState.OPEN, } @@ -108,9 +103,9 @@ class YaleDoorlock(YaleLockEntity, LockEntity): @property def is_locked(self) -> bool | None: """Return true if the lock is locked.""" - return LOCK_STATE_MAP.get(self.lock_data.state()) == STATE_LOCKED + return LOCK_STATE_MAP.get(self.lock_data.state()) == LockState.LOCKED @property def is_open(self) -> bool | None: """Return true if the lock is open.""" - return LOCK_STATE_MAP.get(self.lock_data.state()) == STATE_OPEN + return LOCK_STATE_MAP.get(self.lock_data.state()) == LockState.OPEN diff --git a/homeassistant/components/zwave_js/lock.py b/homeassistant/components/zwave_js/lock.py index b16c1090ef3..c14517f4b03 100644 --- a/homeassistant/components/zwave_js/lock.py +++ b/homeassistant/components/zwave_js/lock.py @@ -19,9 +19,8 @@ from zwave_js_server.const.command_class.lock import ( from zwave_js_server.exceptions import BaseZwaveJSServerError from zwave_js_server.util.lock import clear_usercode, set_configuration, set_usercode -from homeassistant.components.lock import DOMAIN as LOCK_DOMAIN, LockEntity +from homeassistant.components.lock import DOMAIN as LOCK_DOMAIN, LockEntity, LockState from homeassistant.config_entries import ConfigEntry -from homeassistant.const import STATE_LOCKED, STATE_UNLOCKED from homeassistant.core import HomeAssistant, callback from homeassistant.exceptions import HomeAssistantError from homeassistant.helpers import config_validation as cv, entity_platform @@ -49,12 +48,12 @@ PARALLEL_UPDATES = 0 STATE_TO_ZWAVE_MAP: dict[int, dict[str, int | bool]] = { CommandClass.DOOR_LOCK: { - STATE_UNLOCKED: DoorLockMode.UNSECURED, - STATE_LOCKED: DoorLockMode.SECURED, + LockState.UNLOCKED: DoorLockMode.UNSECURED, + LockState.LOCKED: DoorLockMode.SECURED, }, CommandClass.LOCK: { - STATE_UNLOCKED: False, - STATE_LOCKED: True, + LockState.UNLOCKED: False, + LockState.LOCKED: True, }, } UNIT16_SCHEMA = vol.All(vol.Coerce(int), vol.Range(min=0, max=65535)) @@ -140,7 +139,7 @@ class ZWaveLock(ZWaveBaseEntity, LockEntity): == self.info.primary_value.value ) - async def _set_lock_state(self, target_state: str, **kwargs: Any) -> None: + async def _set_lock_state(self, target_state: LockState, **kwargs: Any) -> None: """Set the lock state.""" target_value = self.get_zwave_value( LOCK_CMD_CLASS_TO_PROPERTY_MAP[ @@ -155,11 +154,11 @@ class ZWaveLock(ZWaveBaseEntity, LockEntity): async def async_lock(self, **kwargs: Any) -> None: """Lock the lock.""" - await self._set_lock_state(STATE_LOCKED) + await self._set_lock_state(LockState.LOCKED) async def async_unlock(self, **kwargs: Any) -> None: """Unlock the lock.""" - await self._set_lock_state(STATE_UNLOCKED) + await self._set_lock_state(LockState.UNLOCKED) async def async_set_lock_usercode(self, code_slot: int, usercode: str) -> None: """Set the usercode to index X on the lock.""" diff --git a/homeassistant/const.py b/homeassistant/const.py index 257fcd2bfd2..4ce98d7e69c 100644 --- a/homeassistant/const.py +++ b/homeassistant/const.py @@ -487,15 +487,39 @@ STATE_ALARM_PENDING: Final = "pending" STATE_ALARM_ARMING: Final = "arming" STATE_ALARM_DISARMING: Final = "disarming" STATE_ALARM_TRIGGERED: Final = "triggered" -STATE_LOCKED: Final = "locked" -STATE_UNLOCKED: Final = "unlocked" -STATE_LOCKING: Final = "locking" -STATE_UNLOCKING: Final = "unlocking" -STATE_JAMMED: Final = "jammed" STATE_UNAVAILABLE: Final = "unavailable" STATE_OK: Final = "ok" STATE_PROBLEM: Final = "problem" +# #### LOCK STATES #### +# STATE_* below are deprecated as of 2024.10 +# use the LockState enum instead. +_DEPRECATED_STATE_LOCKED: Final = DeprecatedConstant( + "locked", + "LockState.LOCKED", + "2025.10", +) +_DEPRECATED_STATE_UNLOCKED: Final = DeprecatedConstant( + "unlocked", + "LockState.UNLOCKED", + "2025.10", +) +_DEPRECATED_STATE_LOCKING: Final = DeprecatedConstant( + "locking", + "LockState.LOCKING", + "2025.10", +) +_DEPRECATED_STATE_UNLOCKING: Final = DeprecatedConstant( + "unlocking", + "LockState.UNLOCKING", + "2025.10", +) +_DEPRECATED_STATE_JAMMED: Final = DeprecatedConstant( + "jammed", + "LockState.JAMMED", + "2025.10", +) + # #### STATE AND EVENT ATTRIBUTES #### # Attribution ATTR_ATTRIBUTION: Final = "attribution" diff --git a/homeassistant/helpers/state.py b/homeassistant/helpers/state.py index 71b1b2658e2..70f64d5296a 100644 --- a/homeassistant/helpers/state.py +++ b/homeassistant/helpers/state.py @@ -9,17 +9,16 @@ import logging from types import ModuleType from typing import Any +from homeassistant.components.lock import LockState from homeassistant.components.sun import STATE_ABOVE_HORIZON, STATE_BELOW_HORIZON from homeassistant.const import ( STATE_CLOSED, STATE_HOME, - STATE_LOCKED, STATE_NOT_HOME, STATE_OFF, STATE_ON, STATE_OPEN, STATE_UNKNOWN, - STATE_UNLOCKED, ) from homeassistant.core import Context, HomeAssistant, State from homeassistant.loader import IntegrationNotFound, async_get_integration, bind_hass @@ -79,7 +78,7 @@ def state_as_number(state: State) -> float: """ if state.state in ( STATE_ON, - STATE_LOCKED, + LockState.LOCKED, STATE_ABOVE_HORIZON, STATE_OPEN, STATE_HOME, @@ -87,7 +86,7 @@ def state_as_number(state: State) -> float: return 1 if state.state in ( STATE_OFF, - STATE_UNLOCKED, + LockState.UNLOCKED, STATE_UNKNOWN, STATE_BELOW_HORIZON, STATE_CLOSED, diff --git a/tests/components/abode/test_lock.py b/tests/components/abode/test_lock.py index 6be1aef22ca..fe203d0b0f4 100644 --- a/tests/components/abode/test_lock.py +++ b/tests/components/abode/test_lock.py @@ -3,13 +3,12 @@ from unittest.mock import patch from homeassistant.components.abode import ATTR_DEVICE_ID -from homeassistant.components.lock import DOMAIN as LOCK_DOMAIN +from homeassistant.components.lock import DOMAIN as LOCK_DOMAIN, LockState from homeassistant.const import ( ATTR_ENTITY_ID, ATTR_FRIENDLY_NAME, SERVICE_LOCK, SERVICE_UNLOCK, - STATE_LOCKED, ) from homeassistant.core import HomeAssistant from homeassistant.helpers import entity_registry as er @@ -34,7 +33,7 @@ async def test_attributes(hass: HomeAssistant) -> None: await setup_platform(hass, LOCK_DOMAIN) state = hass.states.get(DEVICE_ID) - assert state.state == STATE_LOCKED + assert state.state == LockState.LOCKED assert state.attributes.get(ATTR_DEVICE_ID) == "ZW:00000004" assert not state.attributes.get("battery_low") assert not state.attributes.get("no_response") diff --git a/tests/components/alexa/test_capabilities.py b/tests/components/alexa/test_capabilities.py index b56d8054d7b..5acdbdb271a 100644 --- a/tests/components/alexa/test_capabilities.py +++ b/tests/components/alexa/test_capabilities.py @@ -11,7 +11,7 @@ from homeassistant.components.climate import ( ClimateEntityFeature, HVACMode, ) -from homeassistant.components.lock import STATE_JAMMED, STATE_LOCKING, STATE_UNLOCKING +from homeassistant.components.lock import LockState from homeassistant.components.media_player import MediaPlayerEntityFeature from homeassistant.components.valve import ValveEntityFeature from homeassistant.components.water_heater import ( @@ -28,11 +28,9 @@ from homeassistant.const import ( STATE_ALARM_ARMED_HOME, STATE_ALARM_ARMED_NIGHT, STATE_ALARM_DISARMED, - STATE_LOCKED, STATE_OFF, STATE_UNAVAILABLE, STATE_UNKNOWN, - STATE_UNLOCKED, UnitOfTemperature, ) from homeassistant.core import HomeAssistant @@ -392,11 +390,11 @@ async def test_api_remote_set_power_state( async def test_report_lock_state(hass: HomeAssistant) -> None: """Test LockController implements lockState property.""" - hass.states.async_set("lock.locked", STATE_LOCKED, {}) - hass.states.async_set("lock.unlocked", STATE_UNLOCKED, {}) - hass.states.async_set("lock.unlocking", STATE_UNLOCKING, {}) - hass.states.async_set("lock.locking", STATE_LOCKING, {}) - hass.states.async_set("lock.jammed", STATE_JAMMED, {}) + hass.states.async_set("lock.locked", LockState.LOCKED, {}) + hass.states.async_set("lock.unlocked", LockState.UNLOCKED, {}) + hass.states.async_set("lock.unlocking", LockState.UNLOCKING, {}) + hass.states.async_set("lock.locking", LockState.LOCKING, {}) + hass.states.async_set("lock.jammed", LockState.JAMMED, {}) hass.states.async_set("lock.unknown", STATE_UNKNOWN, {}) properties = await reported_properties(hass, "lock.locked") diff --git a/tests/components/august/test_init.py b/tests/components/august/test_init.py index 1bbe8033ec8..3343e85d60a 100644 --- a/tests/components/august/test_init.py +++ b/tests/components/august/test_init.py @@ -9,14 +9,13 @@ from yalexs.const import Brand from yalexs.exceptions import AugustApiAIOHTTPError from homeassistant.components.august.const import DOMAIN -from homeassistant.components.lock import DOMAIN as LOCK_DOMAIN +from homeassistant.components.lock import DOMAIN as LOCK_DOMAIN, LockState from homeassistant.config_entries import ConfigEntryState from homeassistant.const import ( ATTR_ENTITY_ID, SERVICE_LOCK, SERVICE_OPEN, SERVICE_UNLOCK, - STATE_LOCKED, STATE_ON, ) from homeassistant.core import HomeAssistant @@ -192,7 +191,7 @@ async def test_inoperative_locks_are_filtered_out(hass: HomeAssistant) -> None: lock_a6697750d607098bae8d6baa11ef8063_name = hass.states.get( "lock.a6697750d607098bae8d6baa11ef8063_name" ) - assert lock_a6697750d607098bae8d6baa11ef8063_name.state == STATE_LOCKED + assert lock_a6697750d607098bae8d6baa11ef8063_name.state == LockState.LOCKED async def test_lock_has_doorsense(hass: HomeAssistant) -> None: diff --git a/tests/components/august/test_lock.py b/tests/components/august/test_lock.py index e786cebf3e1..1b8c98e299c 100644 --- a/tests/components/august/test_lock.py +++ b/tests/components/august/test_lock.py @@ -10,21 +10,14 @@ from syrupy import SnapshotAssertion from yalexs.manager.activity import INITIAL_LOCK_RESYNC_TIME from yalexs.pubnub_async import AugustPubNub -from homeassistant.components.lock import ( - DOMAIN as LOCK_DOMAIN, - STATE_JAMMED, - STATE_LOCKING, - STATE_UNLOCKING, -) +from homeassistant.components.lock import DOMAIN as LOCK_DOMAIN, LockState from homeassistant.const import ( ATTR_ENTITY_ID, SERVICE_LOCK, SERVICE_OPEN, SERVICE_UNLOCK, - STATE_LOCKED, STATE_UNAVAILABLE, STATE_UNKNOWN, - STATE_UNLOCKED, ) from homeassistant.core import HomeAssistant from homeassistant.exceptions import HomeAssistantError @@ -65,7 +58,7 @@ async def test_lock_changed_by(hass: HomeAssistant) -> None: lock_state = hass.states.get("lock.online_with_doorsense_name") - assert lock_state.state == STATE_LOCKED + assert lock_state.state == LockState.LOCKED assert lock_state.attributes["changed_by"] == "Your favorite elven princess" @@ -76,7 +69,7 @@ async def test_state_locking(hass: HomeAssistant) -> None: activities = await _mock_activities_from_fixture(hass, "get_activity.locking.json") await _create_august_with_devices(hass, [lock_one], activities=activities) - assert hass.states.get("lock.online_with_doorsense_name").state == STATE_LOCKING + assert hass.states.get("lock.online_with_doorsense_name").state == LockState.LOCKING async def test_state_unlocking(hass: HomeAssistant) -> None: @@ -88,7 +81,9 @@ async def test_state_unlocking(hass: HomeAssistant) -> None: ) await _create_august_with_devices(hass, [lock_one], activities=activities) - assert hass.states.get("lock.online_with_doorsense_name").state == STATE_UNLOCKING + assert ( + hass.states.get("lock.online_with_doorsense_name").state == LockState.UNLOCKING + ) async def test_state_jammed(hass: HomeAssistant) -> None: @@ -98,7 +93,7 @@ async def test_state_jammed(hass: HomeAssistant) -> None: activities = await _mock_activities_from_fixture(hass, "get_activity.jammed.json") await _create_august_with_devices(hass, [lock_one], activities=activities) - assert hass.states.get("lock.online_with_doorsense_name").state == STATE_JAMMED + assert hass.states.get("lock.online_with_doorsense_name").state == LockState.JAMMED async def test_one_lock_operation( @@ -111,7 +106,7 @@ async def test_one_lock_operation( lock_state = states.get("lock.online_with_doorsense_name") - assert lock_state.state == STATE_LOCKED + assert lock_state.state == LockState.LOCKED assert lock_state.attributes["battery_level"] == 92 assert lock_state.attributes["friendly_name"] == "online_with_doorsense Name" @@ -120,14 +115,14 @@ async def test_one_lock_operation( await hass.services.async_call(LOCK_DOMAIN, SERVICE_UNLOCK, data, blocking=True) lock_state = states.get("lock.online_with_doorsense_name") - assert lock_state.state == STATE_UNLOCKED + assert lock_state.state == LockState.UNLOCKED assert lock_state.attributes["battery_level"] == 92 assert lock_state.attributes["friendly_name"] == "online_with_doorsense Name" await hass.services.async_call(LOCK_DOMAIN, SERVICE_LOCK, data, blocking=True) - assert states.get("lock.online_with_doorsense_name").state == STATE_LOCKED + assert states.get("lock.online_with_doorsense_name").state == LockState.LOCKED # No activity means it will be unavailable until the activity feed has data lock_operator_sensor = entity_registry.async_get( @@ -145,13 +140,13 @@ async def test_open_lock_operation(hass: HomeAssistant) -> None: await _create_august_with_devices(hass, [lock_with_unlatch]) lock_online_with_unlatch_name = hass.states.get("lock.online_with_unlatch_name") - assert lock_online_with_unlatch_name.state == STATE_LOCKED + assert lock_online_with_unlatch_name.state == LockState.LOCKED data = {ATTR_ENTITY_ID: "lock.online_with_unlatch_name"} await hass.services.async_call(LOCK_DOMAIN, SERVICE_OPEN, data, blocking=True) lock_online_with_unlatch_name = hass.states.get("lock.online_with_unlatch_name") - assert lock_online_with_unlatch_name.state == STATE_UNLOCKED + assert lock_online_with_unlatch_name.state == LockState.UNLOCKED async def test_open_lock_operation_pubnub_connected( @@ -167,7 +162,7 @@ async def test_open_lock_operation_pubnub_connected( await _create_august_with_devices(hass, [lock_with_unlatch], pubnub=pubnub) pubnub.connected = True - assert hass.states.get("lock.online_with_unlatch_name").state == STATE_LOCKED + assert hass.states.get("lock.online_with_unlatch_name").state == LockState.LOCKED data = {ATTR_ENTITY_ID: "lock.online_with_unlatch_name"} await hass.services.async_call(LOCK_DOMAIN, SERVICE_OPEN, data, blocking=True) @@ -185,7 +180,7 @@ async def test_open_lock_operation_pubnub_connected( await hass.async_block_till_done() await hass.async_block_till_done() - assert hass.states.get("lock.online_with_unlatch_name").state == STATE_UNLOCKED + assert hass.states.get("lock.online_with_unlatch_name").state == LockState.UNLOCKED await hass.async_block_till_done() @@ -204,7 +199,7 @@ async def test_one_lock_operation_pubnub_connected( lock_state = hass.states.get("lock.online_with_doorsense_name") - assert lock_state.state == STATE_LOCKED + assert lock_state.state == LockState.LOCKED assert lock_state.attributes["battery_level"] == 92 assert lock_state.attributes["friendly_name"] == "online_with_doorsense Name" @@ -226,7 +221,7 @@ async def test_one_lock_operation_pubnub_connected( await hass.async_block_till_done() lock_state = hass.states.get("lock.online_with_doorsense_name") - assert lock_state.state == STATE_UNLOCKED + assert lock_state.state == LockState.UNLOCKED assert lock_state.attributes["battery_level"] == 92 assert lock_state.attributes["friendly_name"] == "online_with_doorsense Name" @@ -247,7 +242,7 @@ async def test_one_lock_operation_pubnub_connected( await hass.async_block_till_done() lock_state = hass.states.get("lock.online_with_doorsense_name") - assert lock_state.state == STATE_LOCKED + assert lock_state.state == LockState.LOCKED # No activity means it will be unavailable until the activity feed has data lock_operator_sensor = entity_registry.async_get( @@ -274,7 +269,7 @@ async def test_one_lock_operation_pubnub_connected( await hass.async_block_till_done() lock_state = hass.states.get("lock.online_with_doorsense_name") - assert lock_state.state == STATE_UNLOCKED + assert lock_state.state == LockState.UNLOCKED async def test_lock_jammed(hass: HomeAssistant) -> None: @@ -294,7 +289,7 @@ async def test_lock_jammed(hass: HomeAssistant) -> None: lock_state = hass.states.get("lock.online_with_doorsense_name") - assert lock_state.state == STATE_LOCKED + assert lock_state.state == LockState.LOCKED assert lock_state.attributes["battery_level"] == 92 assert lock_state.attributes["friendly_name"] == "online_with_doorsense Name" @@ -303,7 +298,7 @@ async def test_lock_jammed(hass: HomeAssistant) -> None: await hass.services.async_call(LOCK_DOMAIN, SERVICE_UNLOCK, data, blocking=True) lock_state = hass.states.get("lock.online_with_doorsense_name") - assert lock_state.state == STATE_JAMMED + assert lock_state.state == LockState.JAMMED async def test_lock_throws_exception_on_unknown_status_code( @@ -325,7 +320,7 @@ async def test_lock_throws_exception_on_unknown_status_code( lock_state = hass.states.get("lock.online_with_doorsense_name") - assert lock_state.state == STATE_LOCKED + assert lock_state.state == LockState.LOCKED assert lock_state.attributes["battery_level"] == 92 assert lock_state.attributes["friendly_name"] == "online_with_doorsense Name" @@ -367,7 +362,7 @@ async def test_lock_bridge_online(hass: HomeAssistant) -> None: ) await _create_august_with_devices(hass, [lock_one], activities=activities) - assert hass.states.get("lock.online_with_doorsense_name").state == STATE_LOCKED + assert hass.states.get("lock.online_with_doorsense_name").state == LockState.LOCKED async def test_lock_update_via_pubnub(hass: HomeAssistant) -> None: @@ -383,7 +378,7 @@ async def test_lock_update_via_pubnub(hass: HomeAssistant) -> None: ) pubnub.connected = True - assert states.get("lock.online_with_doorsense_name").state == STATE_LOCKED + assert states.get("lock.online_with_doorsense_name").state == LockState.LOCKED pubnub.message( pubnub, @@ -399,7 +394,7 @@ async def test_lock_update_via_pubnub(hass: HomeAssistant) -> None: await hass.async_block_till_done() await hass.async_block_till_done() - assert states.get("lock.online_with_doorsense_name").state == STATE_UNLOCKING + assert states.get("lock.online_with_doorsense_name").state == LockState.UNLOCKING pubnub.message( pubnub, @@ -415,21 +410,21 @@ async def test_lock_update_via_pubnub(hass: HomeAssistant) -> None: await hass.async_block_till_done() await hass.async_block_till_done() - assert states.get("lock.online_with_doorsense_name").state == STATE_LOCKING + assert states.get("lock.online_with_doorsense_name").state == LockState.LOCKING async_fire_time_changed(hass, dt_util.utcnow() + datetime.timedelta(seconds=30)) await hass.async_block_till_done() - assert hass.states.get("lock.online_with_doorsense_name").state == STATE_LOCKING + assert hass.states.get("lock.online_with_doorsense_name").state == LockState.LOCKING pubnub.connected = True async_fire_time_changed(hass, dt_util.utcnow() + datetime.timedelta(seconds=30)) await hass.async_block_till_done() - assert states.get("lock.online_with_doorsense_name").state == STATE_LOCKING + assert states.get("lock.online_with_doorsense_name").state == LockState.LOCKING # Ensure pubnub status is always preserved async_fire_time_changed(hass, dt_util.utcnow() + datetime.timedelta(hours=2)) await hass.async_block_till_done() - assert states.get("lock.online_with_doorsense_name").state == STATE_LOCKING + assert states.get("lock.online_with_doorsense_name").state == LockState.LOCKING pubnub.message( pubnub, @@ -444,11 +439,11 @@ async def test_lock_update_via_pubnub(hass: HomeAssistant) -> None: await hass.async_block_till_done() await hass.async_block_till_done() - assert states.get("lock.online_with_doorsense_name").state == STATE_UNLOCKING + assert states.get("lock.online_with_doorsense_name").state == LockState.UNLOCKING async_fire_time_changed(hass, dt_util.utcnow() + datetime.timedelta(hours=4)) await hass.async_block_till_done() - assert states.get("lock.online_with_doorsense_name").state == STATE_UNLOCKING + assert states.get("lock.online_with_doorsense_name").state == LockState.UNLOCKING await hass.config_entries.async_unload(config_entry.entry_id) await hass.async_block_till_done() diff --git a/tests/components/deconz/test_lock.py b/tests/components/deconz/test_lock.py index 28d60e403ef..70a7bd732bb 100644 --- a/tests/components/deconz/test_lock.py +++ b/tests/components/deconz/test_lock.py @@ -8,8 +8,9 @@ from homeassistant.components.lock import ( DOMAIN as LOCK_DOMAIN, SERVICE_LOCK, SERVICE_UNLOCK, + LockState, ) -from homeassistant.const import ATTR_ENTITY_ID, STATE_LOCKED, STATE_UNLOCKED +from homeassistant.const import ATTR_ENTITY_ID from homeassistant.core import HomeAssistant from .conftest import WebsocketDataType @@ -43,10 +44,10 @@ async def test_lock_from_light( ) -> None: """Test that all supported lock entities based on lights are created.""" assert len(hass.states.async_all()) == 1 - assert hass.states.get("lock.door_lock").state == STATE_UNLOCKED + assert hass.states.get("lock.door_lock").state == LockState.UNLOCKED await light_ws_data({"state": {"on": True}}) - assert hass.states.get("lock.door_lock").state == STATE_LOCKED + assert hass.states.get("lock.door_lock").state == LockState.LOCKED # Verify service calls @@ -107,10 +108,10 @@ async def test_lock_from_sensor( ) -> None: """Test that all supported lock entities based on sensors are created.""" assert len(hass.states.async_all()) == 2 - assert hass.states.get("lock.door_lock").state == STATE_UNLOCKED + assert hass.states.get("lock.door_lock").state == LockState.UNLOCKED await sensor_ws_data({"state": {"lockstate": "locked"}}) - assert hass.states.get("lock.door_lock").state == STATE_LOCKED + assert hass.states.get("lock.door_lock").state == LockState.LOCKED # Verify service calls diff --git a/tests/components/demo/test_lock.py b/tests/components/demo/test_lock.py index 853b9197ab7..1fc4209d300 100644 --- a/tests/components/demo/test_lock.py +++ b/tests/components/demo/test_lock.py @@ -10,19 +10,9 @@ from homeassistant.components.lock import ( SERVICE_LOCK, SERVICE_OPEN, SERVICE_UNLOCK, - STATE_JAMMED, - STATE_LOCKED, - STATE_LOCKING, - STATE_UNLOCKED, - STATE_UNLOCKING, -) -from homeassistant.const import ( - ATTR_ENTITY_ID, - EVENT_STATE_CHANGED, - STATE_OPEN, - STATE_OPENING, - Platform, + LockState, ) +from homeassistant.const import ATTR_ENTITY_ID, EVENT_STATE_CHANGED, Platform from homeassistant.core import HomeAssistant from homeassistant.setup import async_setup_component @@ -57,7 +47,7 @@ async def setup_comp(hass: HomeAssistant, lock_only: None): async def test_locking(hass: HomeAssistant) -> None: """Test the locking of a lock.""" state = hass.states.get(KITCHEN) - assert state.state == STATE_UNLOCKED + assert state.state == LockState.UNLOCKED await hass.async_block_till_done() state_changes = async_capture_events(hass, EVENT_STATE_CHANGED) @@ -67,17 +57,17 @@ async def test_locking(hass: HomeAssistant) -> None: await hass.async_block_till_done() assert state_changes[0].data["entity_id"] == KITCHEN - assert state_changes[0].data["new_state"].state == STATE_LOCKING + assert state_changes[0].data["new_state"].state == LockState.LOCKING assert state_changes[1].data["entity_id"] == KITCHEN - assert state_changes[1].data["new_state"].state == STATE_LOCKED + assert state_changes[1].data["new_state"].state == LockState.LOCKED @patch.object(demo_lock, "LOCK_UNLOCK_DELAY", 0) async def test_unlocking(hass: HomeAssistant) -> None: """Test the unlocking of a lock.""" state = hass.states.get(FRONT) - assert state.state == STATE_LOCKED + assert state.state == LockState.LOCKED await hass.async_block_till_done() state_changes = async_capture_events(hass, EVENT_STATE_CHANGED) @@ -87,17 +77,17 @@ async def test_unlocking(hass: HomeAssistant) -> None: await hass.async_block_till_done() assert state_changes[0].data["entity_id"] == FRONT - assert state_changes[0].data["new_state"].state == STATE_UNLOCKING + assert state_changes[0].data["new_state"].state == LockState.UNLOCKING assert state_changes[1].data["entity_id"] == FRONT - assert state_changes[1].data["new_state"].state == STATE_UNLOCKED + assert state_changes[1].data["new_state"].state == LockState.UNLOCKED @patch.object(demo_lock, "LOCK_UNLOCK_DELAY", 0) async def test_opening(hass: HomeAssistant) -> None: """Test the opening of a lock.""" state = hass.states.get(OPENABLE_LOCK) - assert state.state == STATE_LOCKED + assert state.state == LockState.LOCKED await hass.async_block_till_done() state_changes = async_capture_events(hass, EVENT_STATE_CHANGED) @@ -107,17 +97,17 @@ async def test_opening(hass: HomeAssistant) -> None: await hass.async_block_till_done() assert state_changes[0].data["entity_id"] == OPENABLE_LOCK - assert state_changes[0].data["new_state"].state == STATE_OPENING + assert state_changes[0].data["new_state"].state == LockState.OPENING assert state_changes[1].data["entity_id"] == OPENABLE_LOCK - assert state_changes[1].data["new_state"].state == STATE_OPEN + assert state_changes[1].data["new_state"].state == LockState.OPEN @patch.object(demo_lock, "LOCK_UNLOCK_DELAY", 0) async def test_jammed_when_locking(hass: HomeAssistant) -> None: """Test the locking of a lock jams.""" state = hass.states.get(POORLY_INSTALLED) - assert state.state == STATE_UNLOCKED + assert state.state == LockState.UNLOCKED await hass.async_block_till_done() state_changes = async_capture_events(hass, EVENT_STATE_CHANGED) @@ -127,10 +117,10 @@ async def test_jammed_when_locking(hass: HomeAssistant) -> None: await hass.async_block_till_done() assert state_changes[0].data["entity_id"] == POORLY_INSTALLED - assert state_changes[0].data["new_state"].state == STATE_LOCKING + assert state_changes[0].data["new_state"].state == LockState.LOCKING assert state_changes[1].data["entity_id"] == POORLY_INSTALLED - assert state_changes[1].data["new_state"].state == STATE_JAMMED + assert state_changes[1].data["new_state"].state == LockState.JAMMED async def test_opening_mocked(hass: HomeAssistant) -> None: diff --git a/tests/components/esphome/test_lock.py b/tests/components/esphome/test_lock.py index 82c24b59a2c..ae54b16d6e2 100644 --- a/tests/components/esphome/test_lock.py +++ b/tests/components/esphome/test_lock.py @@ -2,16 +2,20 @@ from unittest.mock import call -from aioesphomeapi import APIClient, LockCommand, LockEntityState, LockInfo, LockState +from aioesphomeapi import ( + APIClient, + LockCommand, + LockEntityState, + LockInfo, + LockState as ESPHomeLockState, +) from homeassistant.components.lock import ( DOMAIN as LOCK_DOMAIN, SERVICE_LOCK, SERVICE_OPEN, SERVICE_UNLOCK, - STATE_LOCKED, - STATE_LOCKING, - STATE_UNLOCKING, + LockState, ) from homeassistant.const import ATTR_ENTITY_ID from homeassistant.core import HomeAssistant @@ -31,7 +35,7 @@ async def test_lock_entity_no_open( requires_code=False, ) ] - states = [LockEntityState(key=1, state=LockState.UNLOCKING)] + states = [LockEntityState(key=1, state=ESPHomeLockState.UNLOCKING)] user_service = [] await mock_generic_device_entry( mock_client=mock_client, @@ -41,7 +45,7 @@ async def test_lock_entity_no_open( ) state = hass.states.get("lock.test_mylock") assert state is not None - assert state.state == STATE_UNLOCKING + assert state.state == LockState.UNLOCKING await hass.services.async_call( LOCK_DOMAIN, @@ -65,7 +69,7 @@ async def test_lock_entity_start_locked( unique_id="my_lock", ) ] - states = [LockEntityState(key=1, state=LockState.LOCKED)] + states = [LockEntityState(key=1, state=ESPHomeLockState.LOCKED)] user_service = [] await mock_generic_device_entry( mock_client=mock_client, @@ -75,7 +79,7 @@ async def test_lock_entity_start_locked( ) state = hass.states.get("lock.test_mylock") assert state is not None - assert state.state == STATE_LOCKED + assert state.state == LockState.LOCKED async def test_lock_entity_supports_open( @@ -92,7 +96,7 @@ async def test_lock_entity_supports_open( requires_code=True, ) ] - states = [LockEntityState(key=1, state=LockState.LOCKING)] + states = [LockEntityState(key=1, state=ESPHomeLockState.LOCKING)] user_service = [] await mock_generic_device_entry( mock_client=mock_client, @@ -102,7 +106,7 @@ async def test_lock_entity_supports_open( ) state = hass.states.get("lock.test_mylock") assert state is not None - assert state.state == STATE_LOCKING + assert state.state == LockState.LOCKING await hass.services.async_call( LOCK_DOMAIN, diff --git a/tests/components/freedompro/test_lock.py b/tests/components/freedompro/test_lock.py index 94f5609ee47..a17217c49e8 100644 --- a/tests/components/freedompro/test_lock.py +++ b/tests/components/freedompro/test_lock.py @@ -7,8 +7,9 @@ from homeassistant.components.lock import ( DOMAIN as LOCK_DOMAIN, SERVICE_LOCK, SERVICE_UNLOCK, + LockState, ) -from homeassistant.const import ATTR_ENTITY_ID, STATE_LOCKED, STATE_UNLOCKED +from homeassistant.const import ATTR_ENTITY_ID from homeassistant.core import HomeAssistant from homeassistant.helpers import device_registry as dr, entity_registry as er from homeassistant.helpers.entity_component import async_update_entity @@ -39,7 +40,7 @@ async def test_lock_get_state( entity_id = "lock.lock" state = hass.states.get(entity_id) assert state - assert state.state == STATE_UNLOCKED + assert state.state == LockState.UNLOCKED assert state.attributes.get("friendly_name") == "lock" entry = entity_registry.async_get(entity_id) @@ -63,7 +64,7 @@ async def test_lock_get_state( assert entry assert entry.unique_id == uid - assert state.state == STATE_LOCKED + assert state.state == LockState.LOCKED async def test_lock_set_unlock( @@ -87,7 +88,7 @@ async def test_lock_set_unlock( state = hass.states.get(entity_id) assert state - assert state.state == STATE_LOCKED + assert state.state == LockState.LOCKED assert state.attributes.get("friendly_name") == "lock" entry = entity_registry.async_get(entity_id) @@ -113,7 +114,7 @@ async def test_lock_set_unlock( await hass.async_block_till_done() state = hass.states.get(entity_id) - assert state.state == STATE_UNLOCKED + assert state.state == LockState.UNLOCKED async def test_lock_set_lock( @@ -126,7 +127,7 @@ async def test_lock_set_lock( entity_id = "lock.lock" state = hass.states.get(entity_id) assert state - assert state.state == STATE_UNLOCKED + assert state.state == LockState.UNLOCKED assert state.attributes.get("friendly_name") == "lock" entry = entity_registry.async_get(entity_id) @@ -153,4 +154,4 @@ async def test_lock_set_lock( await hass.async_block_till_done() state = hass.states.get(entity_id) - assert state.state == STATE_LOCKED + assert state.state == LockState.LOCKED diff --git a/tests/components/google_assistant/test_trait.py b/tests/components/google_assistant/test_trait.py index 06e898a62fa..77a9027e76d 100644 --- a/tests/components/google_assistant/test_trait.py +++ b/tests/components/google_assistant/test_trait.py @@ -1602,7 +1602,7 @@ async def test_lock_unlock_lock(hass: HomeAssistant) -> None: assert trait.LockUnlockTrait.might_2fa(lock.DOMAIN, LockEntityFeature.OPEN, None) trt = trait.LockUnlockTrait( - hass, State("lock.front_door", lock.STATE_LOCKED), PIN_CONFIG + hass, State("lock.front_door", lock.LockState.LOCKED), PIN_CONFIG ) assert trt.sync_attributes() == {} @@ -1628,7 +1628,7 @@ async def test_lock_unlock_unlocking(hass: HomeAssistant) -> None: assert trait.LockUnlockTrait.might_2fa(lock.DOMAIN, LockEntityFeature.OPEN, None) trt = trait.LockUnlockTrait( - hass, State("lock.front_door", lock.STATE_UNLOCKING), PIN_CONFIG + hass, State("lock.front_door", lock.LockState.UNLOCKING), PIN_CONFIG ) assert trt.sync_attributes() == {} @@ -1645,7 +1645,7 @@ async def test_lock_unlock_lock_jammed(hass: HomeAssistant) -> None: assert trait.LockUnlockTrait.might_2fa(lock.DOMAIN, LockEntityFeature.OPEN, None) trt = trait.LockUnlockTrait( - hass, State("lock.front_door", lock.STATE_JAMMED), PIN_CONFIG + hass, State("lock.front_door", lock.LockState.JAMMED), PIN_CONFIG ) assert trt.sync_attributes() == {} @@ -1670,7 +1670,7 @@ async def test_lock_unlock_unlock(hass: HomeAssistant) -> None: ) trt = trait.LockUnlockTrait( - hass, State("lock.front_door", lock.STATE_LOCKED), PIN_CONFIG + hass, State("lock.front_door", lock.LockState.LOCKED), PIN_CONFIG ) assert trt.sync_attributes() == {} @@ -1706,7 +1706,7 @@ async def test_lock_unlock_unlock(hass: HomeAssistant) -> None: # Test without pin trt = trait.LockUnlockTrait( - hass, State("lock.front_door", lock.STATE_LOCKED), BASIC_CONFIG + hass, State("lock.front_door", lock.LockState.LOCKED), BASIC_CONFIG ) with pytest.raises(error.SmartHomeError) as err: diff --git a/tests/components/group/test_init.py b/tests/components/group/test_init.py index bbbe22cba83..9e6e352e46c 100644 --- a/tests/components/group/test_init.py +++ b/tests/components/group/test_init.py @@ -11,6 +11,7 @@ import pytest from homeassistant.components import group from homeassistant.components.group.registry import GroupIntegrationRegistry +from homeassistant.components.lock import LockState from homeassistant.const import ( ATTR_ASSUMED_STATE, ATTR_FRIENDLY_NAME, @@ -19,17 +20,10 @@ from homeassistant.const import ( SERVICE_RELOAD, STATE_CLOSED, STATE_HOME, - STATE_JAMMED, - STATE_LOCKED, - STATE_LOCKING, STATE_NOT_HOME, STATE_OFF, STATE_ON, - STATE_OPEN, - STATE_OPENING, STATE_UNKNOWN, - STATE_UNLOCKED, - STATE_UNLOCKING, ) from homeassistant.core import CoreState, HomeAssistant from homeassistant.helpers import entity_registry as er @@ -740,78 +734,78 @@ async def test_is_on(hass: HomeAssistant) -> None: ), ( ("cover", "cover"), - (STATE_OPEN, STATE_CLOSED), + (LockState.OPEN, STATE_CLOSED), (STATE_CLOSED, STATE_CLOSED), - (STATE_OPEN, True), + (LockState.OPEN, True), (STATE_CLOSED, False), ), ( ("lock", "lock"), - (STATE_UNLOCKED, STATE_LOCKED), - (STATE_LOCKED, STATE_LOCKED), - (STATE_UNLOCKED, True), - (STATE_LOCKED, False), + (LockState.UNLOCKED, LockState.LOCKED), + (LockState.LOCKED, LockState.LOCKED), + (LockState.UNLOCKED, True), + (LockState.LOCKED, False), ), ( ("cover", "lock"), - (STATE_OPEN, STATE_LOCKED), - (STATE_CLOSED, STATE_LOCKED), + (LockState.OPEN, LockState.LOCKED), + (STATE_CLOSED, LockState.LOCKED), (STATE_ON, True), (STATE_OFF, False), ), ( ("cover", "lock"), - (STATE_OPEN, STATE_UNLOCKED), - (STATE_CLOSED, STATE_LOCKED), + (LockState.OPEN, LockState.UNLOCKED), + (STATE_CLOSED, LockState.LOCKED), (STATE_ON, True), (STATE_OFF, False), ), ( ("cover", "lock", "light"), - (STATE_OPEN, STATE_LOCKED, STATE_ON), - (STATE_CLOSED, STATE_LOCKED, STATE_OFF), + (LockState.OPEN, LockState.LOCKED, STATE_ON), + (STATE_CLOSED, LockState.LOCKED, STATE_OFF), (STATE_ON, True), (STATE_OFF, False), ), ( ("lock", "lock"), - (STATE_OPEN, STATE_LOCKED), - (STATE_LOCKED, STATE_LOCKED), - (STATE_UNLOCKED, True), - (STATE_LOCKED, False), + (LockState.OPEN, LockState.LOCKED), + (LockState.LOCKED, LockState.LOCKED), + (LockState.UNLOCKED, True), + (LockState.LOCKED, False), ), ( ("lock", "lock"), - (STATE_OPENING, STATE_LOCKED), - (STATE_LOCKED, STATE_LOCKED), - (STATE_UNLOCKED, True), - (STATE_LOCKED, False), + (LockState.OPENING, LockState.LOCKED), + (LockState.LOCKED, LockState.LOCKED), + (LockState.UNLOCKED, True), + (LockState.LOCKED, False), ), ( ("lock", "lock"), - (STATE_UNLOCKING, STATE_LOCKED), - (STATE_LOCKED, STATE_LOCKED), - (STATE_UNLOCKED, True), - (STATE_LOCKED, False), + (LockState.UNLOCKING, LockState.LOCKED), + (LockState.LOCKED, LockState.LOCKED), + (LockState.UNLOCKED, True), + (LockState.LOCKED, False), ), ( ("lock", "lock"), - (STATE_LOCKING, STATE_LOCKED), - (STATE_LOCKED, STATE_LOCKED), - (STATE_UNLOCKED, True), - (STATE_LOCKED, False), + (LockState.LOCKING, LockState.LOCKED), + (LockState.LOCKED, LockState.LOCKED), + (LockState.UNLOCKED, True), + (LockState.LOCKED, False), ), ( ("lock", "lock"), - (STATE_JAMMED, STATE_LOCKED), - (STATE_LOCKED, STATE_LOCKED), - (STATE_LOCKED, False), - (STATE_LOCKED, False), + (LockState.JAMMED, LockState.LOCKED), + (LockState.LOCKED, LockState.LOCKED), + (LockState.LOCKED, False), + (LockState.LOCKED, False), ), ( ("cover", "lock"), - (STATE_OPEN, STATE_OPEN), - (STATE_CLOSED, STATE_LOCKED), + (LockState.OPEN, LockState.OPEN), + (STATE_CLOSED, LockState.LOCKED), (STATE_ON, True), (STATE_OFF, False), ), diff --git a/tests/components/group/test_lock.py b/tests/components/group/test_lock.py index 0c62913ae3e..cc255264183 100644 --- a/tests/components/group/test_lock.py +++ b/tests/components/group/test_lock.py @@ -12,18 +12,9 @@ from homeassistant.components.lock import ( SERVICE_LOCK, SERVICE_OPEN, SERVICE_UNLOCK, + LockState, ) -from homeassistant.const import ( - ATTR_ENTITY_ID, - STATE_JAMMED, - STATE_LOCKED, - STATE_LOCKING, - STATE_OPEN, - STATE_UNAVAILABLE, - STATE_UNKNOWN, - STATE_UNLOCKED, - STATE_UNLOCKING, -) +from homeassistant.const import ATTR_ENTITY_ID, STATE_UNAVAILABLE, STATE_UNKNOWN from homeassistant.core import HomeAssistant from homeassistant.exceptions import HomeAssistantError from homeassistant.helpers import entity_registry as er @@ -55,7 +46,7 @@ async def test_default_state( state = hass.states.get("lock.door_group") assert state is not None - assert state.state == STATE_LOCKED + assert state.state == LockState.LOCKED assert state.attributes.get(ATTR_ENTITY_ID) == ["lock.front", "lock.back"] entry = entity_registry.async_get("lock.door_group") @@ -109,63 +100,63 @@ async def test_state_reporting(hass: HomeAssistant) -> None: # At least one member jammed -> group jammed for state_1 in ( - STATE_JAMMED, - STATE_LOCKED, - STATE_LOCKING, + LockState.JAMMED, + LockState.LOCKED, + LockState.LOCKING, STATE_UNAVAILABLE, STATE_UNKNOWN, - STATE_UNLOCKED, - STATE_UNLOCKING, + LockState.UNLOCKED, + LockState.UNLOCKING, ): hass.states.async_set("lock.test1", state_1) - hass.states.async_set("lock.test2", STATE_JAMMED) + hass.states.async_set("lock.test2", LockState.JAMMED) await hass.async_block_till_done() - assert hass.states.get("lock.lock_group").state == STATE_JAMMED + assert hass.states.get("lock.lock_group").state == LockState.JAMMED # At least one member locking -> group unlocking for state_1 in ( - STATE_LOCKED, - STATE_LOCKING, + LockState.LOCKED, + LockState.LOCKING, STATE_UNAVAILABLE, STATE_UNKNOWN, - STATE_UNLOCKED, - STATE_UNLOCKING, + LockState.UNLOCKED, + LockState.UNLOCKING, ): hass.states.async_set("lock.test1", state_1) - hass.states.async_set("lock.test2", STATE_LOCKING) + hass.states.async_set("lock.test2", LockState.LOCKING) await hass.async_block_till_done() - assert hass.states.get("lock.lock_group").state == STATE_LOCKING + assert hass.states.get("lock.lock_group").state == LockState.LOCKING # At least one member unlocking -> group unlocking for state_1 in ( - STATE_LOCKED, + LockState.LOCKED, STATE_UNAVAILABLE, STATE_UNKNOWN, - STATE_UNLOCKED, - STATE_UNLOCKING, + LockState.UNLOCKED, + LockState.UNLOCKING, ): hass.states.async_set("lock.test1", state_1) - hass.states.async_set("lock.test2", STATE_UNLOCKING) + hass.states.async_set("lock.test2", LockState.UNLOCKING) await hass.async_block_till_done() - assert hass.states.get("lock.lock_group").state == STATE_UNLOCKING + assert hass.states.get("lock.lock_group").state == LockState.UNLOCKING # At least one member unlocked -> group unlocked for state_1 in ( - STATE_LOCKED, + LockState.LOCKED, STATE_UNAVAILABLE, STATE_UNKNOWN, - STATE_UNLOCKED, + LockState.UNLOCKED, ): hass.states.async_set("lock.test1", state_1) - hass.states.async_set("lock.test2", STATE_UNLOCKED) + hass.states.async_set("lock.test2", LockState.UNLOCKED) await hass.async_block_till_done() - assert hass.states.get("lock.lock_group").state == STATE_UNLOCKED + assert hass.states.get("lock.lock_group").state == LockState.UNLOCKED # Otherwise -> locked - hass.states.async_set("lock.test1", STATE_LOCKED) - hass.states.async_set("lock.test2", STATE_LOCKED) + hass.states.async_set("lock.test1", LockState.LOCKED) + hass.states.async_set("lock.test2", LockState.LOCKED) await hass.async_block_till_done() - assert hass.states.get("lock.lock_group").state == STATE_LOCKED + assert hass.states.get("lock.lock_group").state == LockState.LOCKED # All group members removed from the state machine -> unavailable hass.states.async_remove("lock.test1") @@ -195,9 +186,9 @@ async def test_service_calls_openable(hass: HomeAssistant) -> None: await hass.async_block_till_done() group_state = hass.states.get("lock.lock_group") - assert group_state.state == STATE_UNLOCKED - assert hass.states.get("lock.openable_lock").state == STATE_LOCKED - assert hass.states.get("lock.another_openable_lock").state == STATE_UNLOCKED + assert group_state.state == LockState.UNLOCKED + assert hass.states.get("lock.openable_lock").state == LockState.LOCKED + assert hass.states.get("lock.another_openable_lock").state == LockState.UNLOCKED await hass.services.async_call( LOCK_DOMAIN, @@ -205,8 +196,8 @@ async def test_service_calls_openable(hass: HomeAssistant) -> None: {ATTR_ENTITY_ID: "lock.lock_group"}, blocking=True, ) - assert hass.states.get("lock.openable_lock").state == STATE_OPEN - assert hass.states.get("lock.another_openable_lock").state == STATE_OPEN + assert hass.states.get("lock.openable_lock").state == LockState.OPEN + assert hass.states.get("lock.another_openable_lock").state == LockState.OPEN await hass.services.async_call( LOCK_DOMAIN, @@ -214,8 +205,8 @@ async def test_service_calls_openable(hass: HomeAssistant) -> None: {ATTR_ENTITY_ID: "lock.lock_group"}, blocking=True, ) - assert hass.states.get("lock.openable_lock").state == STATE_LOCKED - assert hass.states.get("lock.another_openable_lock").state == STATE_LOCKED + assert hass.states.get("lock.openable_lock").state == LockState.LOCKED + assert hass.states.get("lock.another_openable_lock").state == LockState.LOCKED await hass.services.async_call( LOCK_DOMAIN, @@ -223,8 +214,8 @@ async def test_service_calls_openable(hass: HomeAssistant) -> None: {ATTR_ENTITY_ID: "lock.lock_group"}, blocking=True, ) - assert hass.states.get("lock.openable_lock").state == STATE_UNLOCKED - assert hass.states.get("lock.another_openable_lock").state == STATE_UNLOCKED + assert hass.states.get("lock.openable_lock").state == LockState.UNLOCKED + assert hass.states.get("lock.another_openable_lock").state == LockState.UNLOCKED async def test_service_calls_basic(hass: HomeAssistant) -> None: @@ -248,9 +239,9 @@ async def test_service_calls_basic(hass: HomeAssistant) -> None: await hass.async_block_till_done() group_state = hass.states.get("lock.lock_group") - assert group_state.state == STATE_UNLOCKED - assert hass.states.get("lock.basic_lock").state == STATE_LOCKED - assert hass.states.get("lock.another_basic_lock").state == STATE_UNLOCKED + assert group_state.state == LockState.UNLOCKED + assert hass.states.get("lock.basic_lock").state == LockState.LOCKED + assert hass.states.get("lock.another_basic_lock").state == LockState.UNLOCKED await hass.services.async_call( LOCK_DOMAIN, @@ -258,8 +249,8 @@ async def test_service_calls_basic(hass: HomeAssistant) -> None: {ATTR_ENTITY_ID: "lock.lock_group"}, blocking=True, ) - assert hass.states.get("lock.basic_lock").state == STATE_LOCKED - assert hass.states.get("lock.another_basic_lock").state == STATE_LOCKED + assert hass.states.get("lock.basic_lock").state == LockState.LOCKED + assert hass.states.get("lock.another_basic_lock").state == LockState.LOCKED await hass.services.async_call( LOCK_DOMAIN, @@ -267,8 +258,8 @@ async def test_service_calls_basic(hass: HomeAssistant) -> None: {ATTR_ENTITY_ID: "lock.lock_group"}, blocking=True, ) - assert hass.states.get("lock.basic_lock").state == STATE_UNLOCKED - assert hass.states.get("lock.another_basic_lock").state == STATE_UNLOCKED + assert hass.states.get("lock.basic_lock").state == LockState.UNLOCKED + assert hass.states.get("lock.another_basic_lock").state == LockState.UNLOCKED with pytest.raises(HomeAssistantError): await hass.services.async_call( @@ -303,7 +294,7 @@ async def test_reload(hass: HomeAssistant) -> None: await hass.async_start() await hass.async_block_till_done() - assert hass.states.get("lock.lock_group").state == STATE_UNLOCKED + assert hass.states.get("lock.lock_group").state == LockState.UNLOCKED yaml_path = get_fixture_path("configuration.yaml", "group") with patch.object(hass_config, "YAML_CONFIG_FILE", yaml_path): @@ -322,7 +313,7 @@ async def test_reload(hass: HomeAssistant) -> None: async def test_reload_with_platform_not_setup(hass: HomeAssistant) -> None: """Test the ability to reload locks.""" - hass.states.async_set("lock.something", STATE_UNLOCKED) + hass.states.async_set("lock.something", LockState.UNLOCKED) await async_setup_component( hass, LOCK_DOMAIN, @@ -372,11 +363,11 @@ async def test_reload_with_base_integration_platform_not_setup( }, ) await hass.async_block_till_done() - hass.states.async_set("lock.front_lock", STATE_LOCKED) - hass.states.async_set("lock.back_lock", STATE_UNLOCKED) + hass.states.async_set("lock.front_lock", LockState.LOCKED) + hass.states.async_set("lock.back_lock", LockState.UNLOCKED) - hass.states.async_set("lock.outside_lock", STATE_LOCKED) - hass.states.async_set("lock.outside_lock_2", STATE_LOCKED) + hass.states.async_set("lock.outside_lock", LockState.LOCKED) + hass.states.async_set("lock.outside_lock_2", LockState.LOCKED) yaml_path = get_fixture_path("configuration.yaml", "group") with patch.object(hass_config, "YAML_CONFIG_FILE", yaml_path): @@ -391,8 +382,8 @@ async def test_reload_with_base_integration_platform_not_setup( assert hass.states.get("lock.lock_group") is None assert hass.states.get("lock.inside_locks_g") is not None assert hass.states.get("lock.outside_locks_g") is not None - assert hass.states.get("lock.inside_locks_g").state == STATE_UNLOCKED - assert hass.states.get("lock.outside_locks_g").state == STATE_LOCKED + assert hass.states.get("lock.inside_locks_g").state == LockState.UNLOCKED + assert hass.states.get("lock.outside_locks_g").state == LockState.LOCKED @patch.object(demo_lock, "LOCK_UNLOCK_DELAY", 0) @@ -426,7 +417,7 @@ async def test_nested_group(hass: HomeAssistant) -> None: state = hass.states.get("lock.some_group") assert state is not None - assert state.state == STATE_UNLOCKED + assert state.state == LockState.UNLOCKED assert state.attributes.get(ATTR_ENTITY_ID) == [ "lock.front_door", "lock.kitchen_door", @@ -434,7 +425,7 @@ async def test_nested_group(hass: HomeAssistant) -> None: state = hass.states.get("lock.nested_group") assert state is not None - assert state.state == STATE_UNLOCKED + assert state.state == LockState.UNLOCKED assert state.attributes.get(ATTR_ENTITY_ID) == ["lock.some_group"] # Test controlling the nested group @@ -444,7 +435,7 @@ async def test_nested_group(hass: HomeAssistant) -> None: {ATTR_ENTITY_ID: "lock.nested_group"}, blocking=True, ) - assert hass.states.get("lock.front_door").state == STATE_LOCKED - assert hass.states.get("lock.kitchen_door").state == STATE_LOCKED - assert hass.states.get("lock.some_group").state == STATE_LOCKED - assert hass.states.get("lock.nested_group").state == STATE_LOCKED + assert hass.states.get("lock.front_door").state == LockState.LOCKED + assert hass.states.get("lock.kitchen_door").state == LockState.LOCKED + assert hass.states.get("lock.some_group").state == LockState.LOCKED + assert hass.states.get("lock.nested_group").state == LockState.LOCKED diff --git a/tests/components/homekit/test_type_locks.py b/tests/components/homekit/test_type_locks.py index 5b5b355d10f..2961fe52170 100644 --- a/tests/components/homekit/test_type_locks.py +++ b/tests/components/homekit/test_type_locks.py @@ -4,19 +4,12 @@ import pytest from homeassistant.components.homekit.const import ATTR_VALUE from homeassistant.components.homekit.type_locks import Lock -from homeassistant.components.lock import ( - DOMAIN as LOCK_DOMAIN, - STATE_JAMMED, - STATE_LOCKING, - STATE_UNLOCKING, -) +from homeassistant.components.lock import DOMAIN as LOCK_DOMAIN, LockState from homeassistant.const import ( ATTR_CODE, ATTR_ENTITY_ID, - STATE_LOCKED, STATE_UNAVAILABLE, STATE_UNKNOWN, - STATE_UNLOCKED, ) from homeassistant.core import Event, HomeAssistant @@ -40,27 +33,27 @@ async def test_lock_unlock(hass: HomeAssistant, hk_driver, events: list[Event]) assert acc.char_current_state.value == 3 assert acc.char_target_state.value == 1 - hass.states.async_set(entity_id, STATE_LOCKED) + hass.states.async_set(entity_id, LockState.LOCKED) await hass.async_block_till_done() assert acc.char_current_state.value == 1 assert acc.char_target_state.value == 1 - hass.states.async_set(entity_id, STATE_LOCKING) + hass.states.async_set(entity_id, LockState.LOCKING) await hass.async_block_till_done() assert acc.char_current_state.value == 0 assert acc.char_target_state.value == 1 - hass.states.async_set(entity_id, STATE_UNLOCKED) + hass.states.async_set(entity_id, LockState.UNLOCKED) await hass.async_block_till_done() assert acc.char_current_state.value == 0 assert acc.char_target_state.value == 0 - hass.states.async_set(entity_id, STATE_UNLOCKING) + hass.states.async_set(entity_id, LockState.UNLOCKING) await hass.async_block_till_done() assert acc.char_current_state.value == 1 assert acc.char_target_state.value == 0 - hass.states.async_set(entity_id, STATE_JAMMED) + hass.states.async_set(entity_id, LockState.JAMMED) await hass.async_block_till_done() assert acc.char_current_state.value == 2 assert acc.char_target_state.value == 0 @@ -78,7 +71,7 @@ async def test_lock_unlock(hass: HomeAssistant, hk_driver, events: list[Event]) assert acc.char_target_state.value == 0 assert acc.available is False - hass.states.async_set(entity_id, STATE_UNLOCKED) + hass.states.async_set(entity_id, LockState.UNLOCKED) await hass.async_block_till_done() assert acc.char_current_state.value == 0 assert acc.char_target_state.value == 0 diff --git a/tests/components/homematicip_cloud/test_lock.py b/tests/components/homematicip_cloud/test_lock.py index 4eef4526a7a..cb8a0188639 100644 --- a/tests/components/homematicip_cloud/test_lock.py +++ b/tests/components/homematicip_cloud/test_lock.py @@ -2,15 +2,14 @@ from unittest.mock import patch -from homematicip.base.enums import LockState, MotorState +from homematicip.base.enums import LockState as HomematicLockState, MotorState import pytest from homeassistant.components.homematicip_cloud import DOMAIN as HMIPC_DOMAIN from homeassistant.components.lock import ( DOMAIN as LOCK_DOMAIN, - STATE_LOCKING, - STATE_UNLOCKING, LockEntityFeature, + LockState, ) from homeassistant.const import ATTR_SUPPORTED_FEATURES from homeassistant.core import HomeAssistant @@ -52,7 +51,7 @@ async def test_hmip_doorlockdrive( blocking=True, ) assert hmip_device.mock_calls[-1][0] == "set_lock_state" - assert hmip_device.mock_calls[-1][1] == (LockState.OPEN,) + assert hmip_device.mock_calls[-1][1] == (HomematicLockState.OPEN,) await hass.services.async_call( "lock", @@ -61,7 +60,7 @@ async def test_hmip_doorlockdrive( blocking=True, ) assert hmip_device.mock_calls[-1][0] == "set_lock_state" - assert hmip_device.mock_calls[-1][1] == (LockState.LOCKED,) + assert hmip_device.mock_calls[-1][1] == (HomematicLockState.LOCKED,) await hass.services.async_call( "lock", @@ -71,19 +70,19 @@ async def test_hmip_doorlockdrive( ) assert hmip_device.mock_calls[-1][0] == "set_lock_state" - assert hmip_device.mock_calls[-1][1] == (LockState.UNLOCKED,) + assert hmip_device.mock_calls[-1][1] == (HomematicLockState.UNLOCKED,) await async_manipulate_test_data( hass, hmip_device, "motorState", MotorState.CLOSING ) ha_state = hass.states.get(entity_id) - assert ha_state.state == STATE_LOCKING + assert ha_state.state == LockState.LOCKING await async_manipulate_test_data( hass, hmip_device, "motorState", MotorState.OPENING ) ha_state = hass.states.get(entity_id) - assert ha_state.state == STATE_UNLOCKING + assert ha_state.state == LockState.UNLOCKING async def test_hmip_doorlockdrive_handle_errors( diff --git a/tests/components/insteon/test_lock.py b/tests/components/insteon/test_lock.py index f0ed0bbe66f..ec236059c74 100644 --- a/tests/components/insteon/test_lock.py +++ b/tests/components/insteon/test_lock.py @@ -10,15 +10,8 @@ from homeassistant.components.insteon import ( entity as insteon_entity, utils as insteon_utils, ) -from homeassistant.components.lock import ( # SERVICE_LOCK,; SERVICE_UNLOCK, - DOMAIN as LOCK_DOMAIN, -) -from homeassistant.const import ( # ATTR_ENTITY_ID,; - EVENT_HOMEASSISTANT_STOP, - STATE_LOCKED, - STATE_UNLOCKED, - Platform, -) +from homeassistant.components.lock import DOMAIN as LOCK_DOMAIN, LockState +from homeassistant.const import EVENT_HOMEASSISTANT_STOP, Platform from homeassistant.core import HomeAssistant from homeassistant.helpers import entity_registry as er @@ -73,7 +66,7 @@ async def test_lock_lock( try: lock = entity_registry.async_get("lock.device_55_55_55_55_55_55") state = hass.states.get(lock.entity_id) - assert state.state is STATE_UNLOCKED + assert state.state == LockState.UNLOCKED # lock via UI await hass.services.async_call( @@ -102,7 +95,7 @@ async def test_lock_unlock( lock = entity_registry.async_get("lock.device_55_55_55_55_55_55") state = hass.states.get(lock.entity_id) - assert state.state is STATE_LOCKED + assert state.state == LockState.LOCKED # lock via UI await hass.services.async_call( diff --git a/tests/components/kitchen_sink/test_lock.py b/tests/components/kitchen_sink/test_lock.py index e86300a4d35..a626cccd45c 100644 --- a/tests/components/kitchen_sink/test_lock.py +++ b/tests/components/kitchen_sink/test_lock.py @@ -11,17 +11,9 @@ from homeassistant.components.lock import ( SERVICE_LOCK, SERVICE_OPEN, SERVICE_UNLOCK, - STATE_LOCKED, - STATE_LOCKING, - STATE_UNLOCKED, - STATE_UNLOCKING, -) -from homeassistant.const import ( - ATTR_ENTITY_ID, - EVENT_STATE_CHANGED, - STATE_OPEN, - Platform, + LockState, ) +from homeassistant.const import ATTR_ENTITY_ID, EVENT_STATE_CHANGED, Platform from homeassistant.core import HomeAssistant from homeassistant.setup import async_setup_component @@ -58,7 +50,7 @@ async def test_states(hass: HomeAssistant, snapshot: SnapshotAssertion) -> None: async def test_locking(hass: HomeAssistant) -> None: """Test the locking of a lock.""" state = hass.states.get(UNLOCKED_LOCK) - assert state.state == STATE_UNLOCKED + assert state.state == LockState.UNLOCKED await hass.async_block_till_done() state_changes = async_capture_events(hass, EVENT_STATE_CHANGED) @@ -68,16 +60,16 @@ async def test_locking(hass: HomeAssistant) -> None: await hass.async_block_till_done() assert state_changes[0].data["entity_id"] == UNLOCKED_LOCK - assert state_changes[0].data["new_state"].state == STATE_LOCKING + assert state_changes[0].data["new_state"].state == LockState.LOCKING assert state_changes[1].data["entity_id"] == UNLOCKED_LOCK - assert state_changes[1].data["new_state"].state == STATE_LOCKED + assert state_changes[1].data["new_state"].state == LockState.LOCKED async def test_unlocking(hass: HomeAssistant) -> None: """Test the unlocking of a lock.""" state = hass.states.get(LOCKED_LOCK) - assert state.state == STATE_LOCKED + assert state.state == LockState.LOCKED await hass.async_block_till_done() state_changes = async_capture_events(hass, EVENT_STATE_CHANGED) @@ -87,10 +79,10 @@ async def test_unlocking(hass: HomeAssistant) -> None: await hass.async_block_till_done() assert state_changes[0].data["entity_id"] == LOCKED_LOCK - assert state_changes[0].data["new_state"].state == STATE_UNLOCKING + assert state_changes[0].data["new_state"].state == LockState.UNLOCKING assert state_changes[1].data["entity_id"] == LOCKED_LOCK - assert state_changes[1].data["new_state"].state == STATE_UNLOCKED + assert state_changes[1].data["new_state"].state == LockState.UNLOCKED async def test_opening_mocked(hass: HomeAssistant) -> None: @@ -108,4 +100,4 @@ async def test_opening(hass: HomeAssistant) -> None: LOCK_DOMAIN, SERVICE_OPEN, {ATTR_ENTITY_ID: OPENABLE_LOCK}, blocking=True ) state = hass.states.get(OPENABLE_LOCK) - assert state.state == STATE_OPEN + assert state.state == LockState.OPEN diff --git a/tests/components/lock/test_device_condition.py b/tests/components/lock/test_device_condition.py index 74910e1909f..1818d4933b8 100644 --- a/tests/components/lock/test_device_condition.py +++ b/tests/components/lock/test_device_condition.py @@ -5,17 +5,8 @@ from pytest_unordered import unordered from homeassistant.components import automation from homeassistant.components.device_automation import DeviceAutomationType -from homeassistant.components.lock import DOMAIN -from homeassistant.const import ( - STATE_JAMMED, - STATE_LOCKED, - STATE_LOCKING, - STATE_OPEN, - STATE_OPENING, - STATE_UNLOCKED, - STATE_UNLOCKING, - EntityCategory, -) +from homeassistant.components.lock import DOMAIN, LockState +from homeassistant.const import EntityCategory from homeassistant.core import HomeAssistant, ServiceCall from homeassistant.helpers import device_registry as dr, entity_registry as er from homeassistant.helpers.entity_registry import RegistryEntryHider @@ -142,7 +133,7 @@ async def test_if_state( DOMAIN, "test", "5678", device_id=device_entry.id ) - hass.states.async_set(entry.entity_id, STATE_LOCKED) + hass.states.async_set(entry.entity_id, LockState.LOCKED) assert await async_setup_component( hass, @@ -284,38 +275,38 @@ async def test_if_state( assert len(service_calls) == 1 assert service_calls[0].data["some"] == "is_locked - event - test_event1" - hass.states.async_set(entry.entity_id, STATE_UNLOCKED) + hass.states.async_set(entry.entity_id, LockState.UNLOCKED) hass.bus.async_fire("test_event1") hass.bus.async_fire("test_event2") await hass.async_block_till_done() assert len(service_calls) == 2 assert service_calls[1].data["some"] == "is_unlocked - event - test_event2" - hass.states.async_set(entry.entity_id, STATE_UNLOCKING) + hass.states.async_set(entry.entity_id, LockState.UNLOCKING) hass.bus.async_fire("test_event3") await hass.async_block_till_done() assert len(service_calls) == 3 assert service_calls[2].data["some"] == "is_unlocking - event - test_event3" - hass.states.async_set(entry.entity_id, STATE_LOCKING) + hass.states.async_set(entry.entity_id, LockState.LOCKING) hass.bus.async_fire("test_event4") await hass.async_block_till_done() assert len(service_calls) == 4 assert service_calls[3].data["some"] == "is_locking - event - test_event4" - hass.states.async_set(entry.entity_id, STATE_JAMMED) + hass.states.async_set(entry.entity_id, LockState.JAMMED) hass.bus.async_fire("test_event5") await hass.async_block_till_done() assert len(service_calls) == 5 assert service_calls[4].data["some"] == "is_jammed - event - test_event5" - hass.states.async_set(entry.entity_id, STATE_OPENING) + hass.states.async_set(entry.entity_id, LockState.OPENING) hass.bus.async_fire("test_event6") await hass.async_block_till_done() assert len(service_calls) == 6 assert service_calls[5].data["some"] == "is_opening - event - test_event6" - hass.states.async_set(entry.entity_id, STATE_OPEN) + hass.states.async_set(entry.entity_id, LockState.OPEN) hass.bus.async_fire("test_event7") await hass.async_block_till_done() assert len(service_calls) == 7 @@ -339,7 +330,7 @@ async def test_if_state_legacy( DOMAIN, "test", "5678", device_id=device_entry.id ) - hass.states.async_set(entry.entity_id, STATE_LOCKED) + hass.states.async_set(entry.entity_id, LockState.LOCKED) assert await async_setup_component( hass, diff --git a/tests/components/lock/test_device_trigger.py b/tests/components/lock/test_device_trigger.py index f64334fa29b..3ecdf2a9bca 100644 --- a/tests/components/lock/test_device_trigger.py +++ b/tests/components/lock/test_device_trigger.py @@ -7,17 +7,8 @@ from pytest_unordered import unordered from homeassistant.components import automation from homeassistant.components.device_automation import DeviceAutomationType -from homeassistant.components.lock import DOMAIN, LockEntityFeature -from homeassistant.const import ( - STATE_JAMMED, - STATE_LOCKED, - STATE_LOCKING, - STATE_OPEN, - STATE_OPENING, - STATE_UNLOCKED, - STATE_UNLOCKING, - EntityCategory, -) +from homeassistant.components.lock import DOMAIN, LockEntityFeature, LockState +from homeassistant.const import EntityCategory from homeassistant.core import HomeAssistant, ServiceCall from homeassistant.helpers import device_registry as dr, entity_registry as er from homeassistant.helpers.entity_registry import RegistryEntryHider @@ -218,7 +209,7 @@ async def test_if_fires_on_state_change( DOMAIN, "test", "5678", device_id=device_entry.id ) - hass.states.async_set(entry.entity_id, STATE_UNLOCKED) + hass.states.async_set(entry.entity_id, LockState.UNLOCKED) assert await async_setup_component( hass, @@ -287,7 +278,7 @@ async def test_if_fires_on_state_change( ) # Fake that the entity is turning on. - hass.states.async_set(entry.entity_id, STATE_LOCKED) + hass.states.async_set(entry.entity_id, LockState.LOCKED) await hass.async_block_till_done() assert len(service_calls) == 1 assert ( @@ -296,7 +287,7 @@ async def test_if_fires_on_state_change( ) # Fake that the entity is turning off. - hass.states.async_set(entry.entity_id, STATE_UNLOCKED) + hass.states.async_set(entry.entity_id, LockState.UNLOCKED) await hass.async_block_till_done() assert len(service_calls) == 2 assert ( @@ -305,7 +296,7 @@ async def test_if_fires_on_state_change( ) # Fake that the entity is opens. - hass.states.async_set(entry.entity_id, STATE_OPEN) + hass.states.async_set(entry.entity_id, LockState.OPEN) await hass.async_block_till_done() assert len(service_calls) == 3 assert ( @@ -331,7 +322,7 @@ async def test_if_fires_on_state_change_legacy( DOMAIN, "test", "5678", device_id=device_entry.id ) - hass.states.async_set(entry.entity_id, STATE_UNLOCKED) + hass.states.async_set(entry.entity_id, LockState.UNLOCKED) assert await async_setup_component( hass, @@ -362,7 +353,7 @@ async def test_if_fires_on_state_change_legacy( ) # Fake that the entity is turning on. - hass.states.async_set(entry.entity_id, STATE_LOCKED) + hass.states.async_set(entry.entity_id, LockState.LOCKED) await hass.async_block_till_done() assert len(service_calls) == 1 assert ( @@ -388,7 +379,7 @@ async def test_if_fires_on_state_change_with_for( DOMAIN, "test", "5678", device_id=device_entry.id ) - hass.states.async_set(entry.entity_id, STATE_UNLOCKED) + hass.states.async_set(entry.entity_id, LockState.UNLOCKED) assert await async_setup_component( hass, @@ -511,7 +502,7 @@ async def test_if_fires_on_state_change_with_for( await hass.async_block_till_done() assert len(service_calls) == 0 - hass.states.async_set(entry.entity_id, STATE_LOCKED) + hass.states.async_set(entry.entity_id, LockState.LOCKED) await hass.async_block_till_done() assert len(service_calls) == 0 async_fire_time_changed(hass, dt_util.utcnow() + timedelta(seconds=10)) @@ -523,7 +514,7 @@ async def test_if_fires_on_state_change_with_for( == f"turn_off device - {entry.entity_id} - unlocked - locked - 0:00:05" ) - hass.states.async_set(entry.entity_id, STATE_UNLOCKING) + hass.states.async_set(entry.entity_id, LockState.UNLOCKING) await hass.async_block_till_done() assert len(service_calls) == 1 async_fire_time_changed(hass, dt_util.utcnow() + timedelta(seconds=16)) @@ -535,7 +526,7 @@ async def test_if_fires_on_state_change_with_for( == f"turn_on device - {entry.entity_id} - locked - unlocking - 0:00:05" ) - hass.states.async_set(entry.entity_id, STATE_JAMMED) + hass.states.async_set(entry.entity_id, LockState.JAMMED) await hass.async_block_till_done() assert len(service_calls) == 2 async_fire_time_changed(hass, dt_util.utcnow() + timedelta(seconds=21)) @@ -547,7 +538,7 @@ async def test_if_fires_on_state_change_with_for( == f"turn_off device - {entry.entity_id} - unlocking - jammed - 0:00:05" ) - hass.states.async_set(entry.entity_id, STATE_LOCKING) + hass.states.async_set(entry.entity_id, LockState.LOCKING) await hass.async_block_till_done() assert len(service_calls) == 3 async_fire_time_changed(hass, dt_util.utcnow() + timedelta(seconds=27)) @@ -559,7 +550,7 @@ async def test_if_fires_on_state_change_with_for( == f"turn_on device - {entry.entity_id} - jammed - locking - 0:00:05" ) - hass.states.async_set(entry.entity_id, STATE_OPENING) + hass.states.async_set(entry.entity_id, LockState.OPENING) await hass.async_block_till_done() assert len(service_calls) == 4 async_fire_time_changed(hass, dt_util.utcnow() + timedelta(seconds=27)) diff --git a/tests/components/lock/test_init.py b/tests/components/lock/test_init.py index f0547fbbeae..a80aa78cec2 100644 --- a/tests/components/lock/test_init.py +++ b/tests/components/lock/test_init.py @@ -2,6 +2,7 @@ from __future__ import annotations +from enum import Enum import re from typing import Any @@ -15,14 +16,9 @@ from homeassistant.components.lock import ( SERVICE_LOCK, SERVICE_OPEN, SERVICE_UNLOCK, - STATE_JAMMED, - STATE_LOCKED, - STATE_LOCKING, - STATE_UNLOCKED, - STATE_UNLOCKING, LockEntityFeature, + LockState, ) -from homeassistant.const import STATE_OPEN, STATE_OPENING from homeassistant.core import HomeAssistant from homeassistant.exceptions import ServiceValidationError import homeassistant.helpers.entity_registry as er @@ -67,37 +63,37 @@ async def test_lock_states(hass: HomeAssistant, mock_lock_entity: MockLock) -> N mock_lock_entity._attr_is_locking = True assert mock_lock_entity.is_locking - assert mock_lock_entity.state == STATE_LOCKING + assert mock_lock_entity.state == LockState.LOCKING mock_lock_entity._attr_is_locked = True mock_lock_entity._attr_is_locking = False assert mock_lock_entity.is_locked - assert mock_lock_entity.state == STATE_LOCKED + assert mock_lock_entity.state == LockState.LOCKED mock_lock_entity._attr_is_unlocking = True assert mock_lock_entity.is_unlocking - assert mock_lock_entity.state == STATE_UNLOCKING + assert mock_lock_entity.state == LockState.UNLOCKING mock_lock_entity._attr_is_locked = False mock_lock_entity._attr_is_unlocking = False assert not mock_lock_entity.is_locked - assert mock_lock_entity.state == STATE_UNLOCKED + assert mock_lock_entity.state == LockState.UNLOCKED mock_lock_entity._attr_is_jammed = True assert mock_lock_entity.is_jammed - assert mock_lock_entity.state == STATE_JAMMED + assert mock_lock_entity.state == LockState.JAMMED assert not mock_lock_entity.is_locked mock_lock_entity._attr_is_jammed = False mock_lock_entity._attr_is_opening = True assert mock_lock_entity.is_opening - assert mock_lock_entity.state == STATE_OPENING + assert mock_lock_entity.state == LockState.OPENING assert mock_lock_entity.is_opening mock_lock_entity._attr_is_opening = False mock_lock_entity._attr_is_open = True assert not mock_lock_entity.is_opening - assert mock_lock_entity.state == STATE_OPEN + assert mock_lock_entity.state == LockState.OPEN assert not mock_lock_entity.is_opening assert mock_lock_entity.is_open @@ -393,13 +389,35 @@ def test_all() -> None: help_test_all(lock) -@pytest.mark.parametrize(("enum"), list(LockEntityFeature)) +def _create_tuples( + enum: type[Enum], constant_prefix: str, remove_in_version: str +) -> list[tuple[Enum, str]]: + return [ + (enum_field, constant_prefix, remove_in_version) + for enum_field in enum + if enum_field + not in [ + lock.LockState.OPEN, + lock.LockState.OPENING, + ] + ] + + +@pytest.mark.parametrize( + ("enum", "constant_prefix", "remove_in_version"), + _create_tuples(lock.LockEntityFeature, "SUPPORT_", "2025.1") + + _create_tuples(lock.LockState, "STATE_", "2025.10"), +) def test_deprecated_constants( caplog: pytest.LogCaptureFixture, - enum: LockEntityFeature, + enum: Enum, + constant_prefix: str, + remove_in_version: str, ) -> None: """Test deprecated constants.""" - import_and_test_deprecated_constant_enum(caplog, lock, enum, "SUPPORT_", "2025.1") + import_and_test_deprecated_constant_enum( + caplog, lock, enum, constant_prefix, remove_in_version + ) def test_deprecated_supported_features_ints(caplog: pytest.LogCaptureFixture) -> None: diff --git a/tests/components/loqed/test_lock.py b/tests/components/loqed/test_lock.py index 5fd00b66c43..89a7888571a 100644 --- a/tests/components/loqed/test_lock.py +++ b/tests/components/loqed/test_lock.py @@ -2,6 +2,7 @@ from loqedAPI import loqed +from homeassistant.components.lock import LockState from homeassistant.components.loqed import LoqedDataCoordinator from homeassistant.components.loqed.const import DOMAIN from homeassistant.const import ( @@ -9,8 +10,6 @@ from homeassistant.const import ( SERVICE_LOCK, SERVICE_OPEN, SERVICE_UNLOCK, - STATE_LOCKED, - STATE_UNLOCKED, ) from homeassistant.core import HomeAssistant @@ -27,7 +26,7 @@ async def test_lock_entity( state = hass.states.get(entity_id) assert state - assert state.state == STATE_UNLOCKED + assert state.state == LockState.UNLOCKED async def test_lock_responds_to_bolt_state_updates( @@ -43,7 +42,7 @@ async def test_lock_responds_to_bolt_state_updates( state = hass.states.get(entity_id) assert state - assert state.state == STATE_LOCKED + assert state.state == LockState.LOCKED async def test_lock_transition_to_unlocked( diff --git a/tests/components/matter/test_lock.py b/tests/components/matter/test_lock.py index f279430b393..ee2f3154f31 100644 --- a/tests/components/matter/test_lock.py +++ b/tests/components/matter/test_lock.py @@ -6,13 +6,8 @@ from chip.clusters import Objects as clusters from matter_server.client.models.node import MatterNode import pytest -from homeassistant.components.lock import ( - STATE_LOCKED, - STATE_OPEN, - STATE_UNLOCKED, - LockEntityFeature, -) -from homeassistant.const import ATTR_CODE, STATE_LOCKING, STATE_OPENING, STATE_UNKNOWN +from homeassistant.components.lock import LockEntityFeature, LockState +from homeassistant.const import ATTR_CODE, STATE_UNKNOWN from homeassistant.core import HomeAssistant from homeassistant.exceptions import ServiceValidationError import homeassistant.helpers.entity_registry as er @@ -67,28 +62,28 @@ async def test_lock( await hass.async_block_till_done() state = hass.states.get("lock.mock_door_lock_lock") assert state - assert state.state == STATE_LOCKING + assert state.state == LockState.LOCKING set_node_attribute(door_lock, 1, 257, 0, 0) await trigger_subscription_callback(hass, matter_client) state = hass.states.get("lock.mock_door_lock_lock") assert state - assert state.state == STATE_UNLOCKED + assert state.state == LockState.UNLOCKED set_node_attribute(door_lock, 1, 257, 0, 2) await trigger_subscription_callback(hass, matter_client) state = hass.states.get("lock.mock_door_lock_lock") assert state - assert state.state == STATE_UNLOCKED + assert state.state == LockState.UNLOCKED set_node_attribute(door_lock, 1, 257, 0, 1) await trigger_subscription_callback(hass, matter_client) state = hass.states.get("lock.mock_door_lock_lock") assert state - assert state.state == STATE_LOCKED + assert state.state == LockState.LOCKED set_node_attribute(door_lock, 1, 257, 0, None) await trigger_subscription_callback(hass, matter_client) @@ -178,7 +173,7 @@ async def test_lock_with_unbolt( """Test door lock.""" state = hass.states.get("lock.mock_door_lock_lock") assert state - assert state.state == STATE_LOCKED + assert state.state == LockState.LOCKED assert state.attributes["supported_features"] & LockEntityFeature.OPEN # test unlock/unbolt await hass.services.async_call( @@ -218,18 +213,18 @@ async def test_lock_with_unbolt( await hass.async_block_till_done() state = hass.states.get("lock.mock_door_lock_lock") assert state - assert state.state == STATE_OPENING + assert state.state == LockState.OPENING set_node_attribute(door_lock_with_unbolt, 1, 257, 0, 0) await trigger_subscription_callback(hass, matter_client) state = hass.states.get("lock.mock_door_lock_lock") assert state - assert state.state == STATE_UNLOCKED + assert state.state == LockState.UNLOCKED set_node_attribute(door_lock_with_unbolt, 1, 257, 0, 3) await trigger_subscription_callback(hass, matter_client) state = hass.states.get("lock.mock_door_lock_lock") assert state - assert state.state == STATE_OPEN + assert state.state == LockState.OPEN diff --git a/tests/components/mqtt/test_lock.py b/tests/components/mqtt/test_lock.py index 331f21a0a7c..034f9b5ff6e 100644 --- a/tests/components/mqtt/test_lock.py +++ b/tests/components/mqtt/test_lock.py @@ -10,14 +10,8 @@ from homeassistant.components.lock import ( SERVICE_LOCK, SERVICE_OPEN, SERVICE_UNLOCK, - STATE_JAMMED, - STATE_LOCKED, - STATE_LOCKING, - STATE_OPEN, - STATE_OPENING, - STATE_UNLOCKED, - STATE_UNLOCKING, LockEntityFeature, + LockState, ) from homeassistant.components.mqtt.lock import MQTT_LOCK_ATTRIBUTES_BLOCKED from homeassistant.const import ( @@ -89,12 +83,12 @@ CONFIG_WITH_STATES = { @pytest.mark.parametrize( ("hass_config", "payload", "lock_state"), [ - (CONFIG_WITH_STATES, "closed", STATE_LOCKED), - (CONFIG_WITH_STATES, "closing", STATE_LOCKING), - (CONFIG_WITH_STATES, "open", STATE_OPEN), - (CONFIG_WITH_STATES, "opening", STATE_OPENING), - (CONFIG_WITH_STATES, "unlocked", STATE_UNLOCKED), - (CONFIG_WITH_STATES, "unlocking", STATE_UNLOCKING), + (CONFIG_WITH_STATES, "closed", LockState.LOCKED), + (CONFIG_WITH_STATES, "closing", LockState.LOCKING), + (CONFIG_WITH_STATES, "open", LockState.OPEN), + (CONFIG_WITH_STATES, "opening", LockState.OPENING), + (CONFIG_WITH_STATES, "unlocked", LockState.UNLOCKED), + (CONFIG_WITH_STATES, "unlocking", LockState.UNLOCKING), ], ) async def test_controlling_state_via_topic( @@ -115,18 +109,18 @@ async def test_controlling_state_via_topic( await hass.async_block_till_done() state = hass.states.get("lock.test") - assert state.state is lock_state + assert state.state == lock_state @pytest.mark.parametrize( ("hass_config", "payload", "lock_state"), [ - (CONFIG_WITH_STATES, "closed", STATE_LOCKED), - (CONFIG_WITH_STATES, "closing", STATE_LOCKING), - (CONFIG_WITH_STATES, "open", STATE_OPEN), - (CONFIG_WITH_STATES, "opening", STATE_OPENING), - (CONFIG_WITH_STATES, "unlocked", STATE_UNLOCKED), - (CONFIG_WITH_STATES, "unlocking", STATE_UNLOCKING), + (CONFIG_WITH_STATES, "closed", LockState.LOCKED), + (CONFIG_WITH_STATES, "closing", LockState.LOCKING), + (CONFIG_WITH_STATES, "open", LockState.OPEN), + (CONFIG_WITH_STATES, "opening", LockState.OPENING), + (CONFIG_WITH_STATES, "unlocked", LockState.UNLOCKED), + (CONFIG_WITH_STATES, "unlocking", LockState.UNLOCKING), (CONFIG_WITH_STATES, "None", STATE_UNKNOWN), ], ) @@ -146,13 +140,13 @@ async def test_controlling_non_default_state_via_topic( async_fire_mqtt_message(hass, "state-topic", payload) state = hass.states.get("lock.test") - assert state.state is lock_state + assert state.state == lock_state # Empty state is ignored async_fire_mqtt_message(hass, "state-topic", "") state = hass.states.get("lock.test") - assert state.state is lock_state + assert state.state == lock_state @pytest.mark.parametrize( @@ -165,7 +159,7 @@ async def test_controlling_non_default_state_via_topic( ({"value_template": "{{ value_json.val }}"},), ), '{"val":"closed"}', - STATE_LOCKED, + LockState.LOCKED, ), ( help_custom_config( @@ -174,7 +168,7 @@ async def test_controlling_non_default_state_via_topic( ({"value_template": "{{ value_json.val }}"},), ), '{"val":"closing"}', - STATE_LOCKING, + LockState.LOCKING, ), ( help_custom_config( @@ -183,7 +177,7 @@ async def test_controlling_non_default_state_via_topic( ({"value_template": "{{ value_json.val }}"},), ), '{"val":"unlocking"}', - STATE_UNLOCKING, + LockState.UNLOCKING, ), ( help_custom_config( @@ -192,7 +186,7 @@ async def test_controlling_non_default_state_via_topic( ({"value_template": "{{ value_json.val }}"},), ), '{"val":"open"}', - STATE_OPEN, + LockState.OPEN, ), ( help_custom_config( @@ -201,7 +195,7 @@ async def test_controlling_non_default_state_via_topic( ({"value_template": "{{ value_json.val }}"},), ), '{"val":"opening"}', - STATE_OPENING, + LockState.OPENING, ), ( help_custom_config( @@ -210,7 +204,7 @@ async def test_controlling_non_default_state_via_topic( ({"value_template": "{{ value_json.val }}"},), ), '{"val":"unlocked"}', - STATE_UNLOCKED, + LockState.UNLOCKED, ), ( help_custom_config( @@ -238,7 +232,7 @@ async def test_controlling_state_via_topic_and_json_message( async_fire_mqtt_message(hass, "state-topic", payload) state = hass.states.get("lock.test") - assert state.state is lock_state + assert state.state == lock_state @pytest.mark.parametrize( @@ -251,7 +245,7 @@ async def test_controlling_state_via_topic_and_json_message( ({"value_template": "{{ value_json.val }}"},), ), '{"val":"closed"}', - STATE_LOCKED, + LockState.LOCKED, ), ( help_custom_config( @@ -260,7 +254,7 @@ async def test_controlling_state_via_topic_and_json_message( ({"value_template": "{{ value_json.val }}"},), ), '{"val":"closing"}', - STATE_LOCKING, + LockState.LOCKING, ), ( help_custom_config( @@ -269,7 +263,7 @@ async def test_controlling_state_via_topic_and_json_message( ({"value_template": "{{ value_json.val }}"},), ), '{"val":"open"}', - STATE_OPEN, + LockState.OPEN, ), ( help_custom_config( @@ -278,7 +272,7 @@ async def test_controlling_state_via_topic_and_json_message( ({"value_template": "{{ value_json.val }}"},), ), '{"val":"opening"}', - STATE_OPENING, + LockState.OPENING, ), ( help_custom_config( @@ -287,7 +281,7 @@ async def test_controlling_state_via_topic_and_json_message( ({"value_template": "{{ value_json.val }}"},), ), '{"val":"unlocked"}', - STATE_UNLOCKED, + LockState.UNLOCKED, ), ( help_custom_config( @@ -296,7 +290,7 @@ async def test_controlling_state_via_topic_and_json_message( ({"value_template": "{{ value_json.val }}"},), ), '{"val":"unlocking"}', - STATE_UNLOCKING, + LockState.UNLOCKING, ), ], ) @@ -315,7 +309,7 @@ async def test_controlling_non_default_state_via_topic_and_json_message( async_fire_mqtt_message(hass, "state-topic", payload) state = hass.states.get("lock.test") - assert state.state is lock_state + assert state.state == lock_state @pytest.mark.parametrize( @@ -342,7 +336,7 @@ async def test_sending_mqtt_commands_and_optimistic( mqtt_mock = await mqtt_mock_entry() state = hass.states.get("lock.test") - assert state.state is STATE_UNLOCKED + assert state.state == LockState.UNLOCKED assert state.attributes.get(ATTR_ASSUMED_STATE) await hass.services.async_call( @@ -352,7 +346,7 @@ async def test_sending_mqtt_commands_and_optimistic( mqtt_mock.async_publish.assert_called_once_with("command-topic", "LOCK", 0, False) mqtt_mock.async_publish.reset_mock() state = hass.states.get("lock.test") - assert state.state is STATE_LOCKED + assert state.state == LockState.LOCKED assert state.attributes.get(ATTR_ASSUMED_STATE) await hass.services.async_call( @@ -362,7 +356,7 @@ async def test_sending_mqtt_commands_and_optimistic( mqtt_mock.async_publish.assert_called_once_with("command-topic", "UNLOCK", 0, False) mqtt_mock.async_publish.reset_mock() state = hass.states.get("lock.test") - assert state.state is STATE_UNLOCKED + assert state.state == LockState.UNLOCKED assert state.attributes.get(ATTR_ASSUMED_STATE) @@ -393,7 +387,7 @@ async def test_sending_mqtt_commands_with_template( mqtt_mock = await mqtt_mock_entry() state = hass.states.get("lock.test") - assert state.state is STATE_UNLOCKED + assert state.state == LockState.UNLOCKED assert state.attributes.get(ATTR_ASSUMED_STATE) await hass.services.async_call( @@ -408,7 +402,7 @@ async def test_sending_mqtt_commands_with_template( ) mqtt_mock.async_publish.reset_mock() state = hass.states.get("lock.test") - assert state.state is STATE_LOCKED + assert state.state == LockState.LOCKED assert state.attributes.get(ATTR_ASSUMED_STATE) await hass.services.async_call( @@ -423,7 +417,7 @@ async def test_sending_mqtt_commands_with_template( ) mqtt_mock.async_publish.reset_mock() state = hass.states.get("lock.test") - assert state.state is STATE_UNLOCKED + assert state.state == LockState.UNLOCKED assert state.attributes.get(ATTR_ASSUMED_STATE) @@ -453,7 +447,7 @@ async def test_sending_mqtt_commands_and_explicit_optimistic( mqtt_mock = await mqtt_mock_entry() state = hass.states.get("lock.test") - assert state.state is STATE_UNLOCKED + assert state.state == LockState.UNLOCKED assert state.attributes.get(ATTR_ASSUMED_STATE) await hass.services.async_call( @@ -463,7 +457,7 @@ async def test_sending_mqtt_commands_and_explicit_optimistic( mqtt_mock.async_publish.assert_called_once_with("command-topic", "LOCK", 0, False) mqtt_mock.async_publish.reset_mock() state = hass.states.get("lock.test") - assert state.state is STATE_LOCKED + assert state.state == LockState.LOCKED assert state.attributes.get(ATTR_ASSUMED_STATE) await hass.services.async_call( @@ -473,7 +467,7 @@ async def test_sending_mqtt_commands_and_explicit_optimistic( mqtt_mock.async_publish.assert_called_once_with("command-topic", "UNLOCK", 0, False) mqtt_mock.async_publish.reset_mock() state = hass.states.get("lock.test") - assert state.state is STATE_UNLOCKED + assert state.state == LockState.UNLOCKED assert state.attributes.get(ATTR_ASSUMED_STATE) @@ -502,7 +496,7 @@ async def test_sending_mqtt_commands_support_open_and_optimistic( mqtt_mock = await mqtt_mock_entry() state = hass.states.get("lock.test") - assert state.state is STATE_UNLOCKED + assert state.state == LockState.UNLOCKED assert state.attributes.get(ATTR_ASSUMED_STATE) assert state.attributes.get(ATTR_SUPPORTED_FEATURES) == LockEntityFeature.OPEN @@ -513,7 +507,7 @@ async def test_sending_mqtt_commands_support_open_and_optimistic( mqtt_mock.async_publish.assert_called_once_with("command-topic", "LOCK", 0, False) mqtt_mock.async_publish.reset_mock() state = hass.states.get("lock.test") - assert state.state is STATE_LOCKED + assert state.state == LockState.LOCKED assert state.attributes.get(ATTR_ASSUMED_STATE) await hass.services.async_call( @@ -523,7 +517,7 @@ async def test_sending_mqtt_commands_support_open_and_optimistic( mqtt_mock.async_publish.assert_called_once_with("command-topic", "UNLOCK", 0, False) mqtt_mock.async_publish.reset_mock() state = hass.states.get("lock.test") - assert state.state is STATE_UNLOCKED + assert state.state == LockState.UNLOCKED assert state.attributes.get(ATTR_ASSUMED_STATE) await hass.services.async_call( @@ -533,7 +527,7 @@ async def test_sending_mqtt_commands_support_open_and_optimistic( mqtt_mock.async_publish.assert_called_once_with("command-topic", "OPEN", 0, False) mqtt_mock.async_publish.reset_mock() state = hass.states.get("lock.test") - assert state.state is STATE_OPEN + assert state.state == LockState.OPEN assert state.attributes.get(ATTR_ASSUMED_STATE) @@ -564,7 +558,7 @@ async def test_sending_mqtt_commands_support_open_and_explicit_optimistic( mqtt_mock = await mqtt_mock_entry() state = hass.states.get("lock.test") - assert state.state is STATE_UNLOCKED + assert state.state == LockState.UNLOCKED assert state.attributes.get(ATTR_ASSUMED_STATE) assert state.attributes.get(ATTR_SUPPORTED_FEATURES) == LockEntityFeature.OPEN @@ -575,7 +569,7 @@ async def test_sending_mqtt_commands_support_open_and_explicit_optimistic( mqtt_mock.async_publish.assert_called_once_with("command-topic", "LOCK", 0, False) mqtt_mock.async_publish.reset_mock() state = hass.states.get("lock.test") - assert state.state is STATE_LOCKED + assert state.state == LockState.LOCKED assert state.attributes.get(ATTR_ASSUMED_STATE) await hass.services.async_call( @@ -585,7 +579,7 @@ async def test_sending_mqtt_commands_support_open_and_explicit_optimistic( mqtt_mock.async_publish.assert_called_once_with("command-topic", "UNLOCK", 0, False) mqtt_mock.async_publish.reset_mock() state = hass.states.get("lock.test") - assert state.state is STATE_UNLOCKED + assert state.state == LockState.UNLOCKED assert state.attributes.get(ATTR_ASSUMED_STATE) await hass.services.async_call( @@ -595,7 +589,7 @@ async def test_sending_mqtt_commands_support_open_and_explicit_optimistic( mqtt_mock.async_publish.assert_called_once_with("command-topic", "OPEN", 0, False) mqtt_mock.async_publish.reset_mock() state = hass.states.get("lock.test") - assert state.state is STATE_OPEN + assert state.state == LockState.OPEN assert state.attributes.get(ATTR_ASSUMED_STATE) @@ -644,7 +638,7 @@ async def test_sending_mqtt_commands_pessimistic( await hass.async_block_till_done() state = hass.states.get("lock.test") - assert state.state is STATE_LOCKED + assert state.state == LockState.LOCKED await hass.services.async_call( lock.DOMAIN, SERVICE_UNLOCK, {ATTR_ENTITY_ID: "lock.test"}, blocking=True @@ -658,7 +652,7 @@ async def test_sending_mqtt_commands_pessimistic( await hass.async_block_till_done() state = hass.states.get("lock.test") - assert state.state is STATE_UNLOCKED + assert state.state == LockState.UNLOCKED await hass.services.async_call( lock.DOMAIN, SERVICE_OPEN, {ATTR_ENTITY_ID: "lock.test"}, blocking=True @@ -672,7 +666,7 @@ async def test_sending_mqtt_commands_pessimistic( await hass.async_block_till_done() state = hass.states.get("lock.test") - assert state.state is STATE_UNLOCKED + assert state.state == LockState.UNLOCKED # send lock command to lock await hass.services.async_call( @@ -688,21 +682,21 @@ async def test_sending_mqtt_commands_pessimistic( await hass.async_block_till_done() state = hass.states.get("lock.test") - assert state.state is STATE_LOCKING + assert state.state == LockState.LOCKING # receive jammed state from lock async_fire_mqtt_message(hass, "state-topic", "JAMMED") await hass.async_block_till_done() state = hass.states.get("lock.test") - assert state.state is STATE_JAMMED + assert state.state == LockState.JAMMED # receive solved state from lock async_fire_mqtt_message(hass, "state-topic", "LOCKED") await hass.async_block_till_done() state = hass.states.get("lock.test") - assert state.state is STATE_LOCKED + assert state.state == LockState.LOCKED @pytest.mark.parametrize("hass_config", [DEFAULT_CONFIG]) diff --git a/tests/components/prometheus/test_init.py b/tests/components/prometheus/test_init.py index 0dfa3210671..b505fc81a35 100644 --- a/tests/components/prometheus/test_init.py +++ b/tests/components/prometheus/test_init.py @@ -50,6 +50,7 @@ from homeassistant.components.fan import ( DIRECTION_REVERSE, ) from homeassistant.components.humidifier import ATTR_AVAILABLE_MODES +from homeassistant.components.lock import LockState from homeassistant.components.sensor import SensorDeviceClass from homeassistant.const import ( ATTR_BATTERY_LEVEL, @@ -67,14 +68,12 @@ from homeassistant.const import ( STATE_CLOSED, STATE_CLOSING, STATE_HOME, - STATE_LOCKED, STATE_NOT_HOME, STATE_OFF, STATE_ON, STATE_OPEN, STATE_OPENING, STATE_UNAVAILABLE, - STATE_UNLOCKED, UnitOfEnergy, UnitOfTemperature, ) @@ -1571,7 +1570,7 @@ async def lock_fixture( suggested_object_id="front_door", original_name="Front Door", ) - set_state_with_entry(hass, lock_1, STATE_LOCKED) + set_state_with_entry(hass, lock_1, LockState.LOCKED) data["lock_1"] = lock_1 lock_2 = entity_registry.async_get_or_create( @@ -1581,7 +1580,7 @@ async def lock_fixture( suggested_object_id="kitchen_door", original_name="Kitchen Door", ) - set_state_with_entry(hass, lock_2, STATE_UNLOCKED) + set_state_with_entry(hass, lock_2, LockState.UNLOCKED) data["lock_2"] = lock_2 await hass.async_block_till_done() diff --git a/tests/components/recorder/test_init.py b/tests/components/recorder/test_init.py index 3bbc78e21ce..d16712e0c70 100644 --- a/tests/components/recorder/test_init.py +++ b/tests/components/recorder/test_init.py @@ -17,6 +17,7 @@ from sqlalchemy.exc import DatabaseError, OperationalError, SQLAlchemyError from sqlalchemy.pool import QueuePool from homeassistant.components import recorder +from homeassistant.components.lock import LockState from homeassistant.components.recorder import ( CONF_AUTO_PURGE, CONF_AUTO_REPACK, @@ -69,8 +70,6 @@ from homeassistant.const import ( EVENT_HOMEASSISTANT_STARTED, EVENT_HOMEASSISTANT_STOP, MATCH_ALL, - STATE_LOCKED, - STATE_UNLOCKED, ) from homeassistant.core import Context, CoreState, Event, HomeAssistant, State, callback from homeassistant.helpers import ( @@ -834,8 +833,8 @@ async def test_saving_state_and_removing_entity( ) -> None: """Test saving the state of a removed entity.""" entity_id = "lock.mine" - hass.states.async_set(entity_id, STATE_LOCKED) - hass.states.async_set(entity_id, STATE_UNLOCKED) + hass.states.async_set(entity_id, LockState.LOCKED) + hass.states.async_set(entity_id, LockState.UNLOCKED) hass.states.async_remove(entity_id) await async_wait_recording_done(hass) @@ -848,9 +847,9 @@ async def test_saving_state_and_removing_entity( ) assert len(states) == 3 assert states[0].entity_id == entity_id - assert states[0].state == STATE_LOCKED + assert states[0].state == LockState.LOCKED assert states[1].entity_id == entity_id - assert states[1].state == STATE_UNLOCKED + assert states[1].state == LockState.UNLOCKED assert states[2].entity_id == entity_id assert states[2].state is None diff --git a/tests/components/schlage/test_lock.py b/tests/components/schlage/test_lock.py index 74af80dce84..518c723d581 100644 --- a/tests/components/schlage/test_lock.py +++ b/tests/components/schlage/test_lock.py @@ -5,15 +5,9 @@ from unittest.mock import Mock from freezegun.api import FrozenDateTimeFactory -from homeassistant.components.lock import DOMAIN as LOCK_DOMAIN +from homeassistant.components.lock import DOMAIN as LOCK_DOMAIN, LockState from homeassistant.config_entries import ConfigEntry -from homeassistant.const import ( - ATTR_ENTITY_ID, - SERVICE_LOCK, - SERVICE_UNLOCK, - STATE_JAMMED, - STATE_UNLOCKED, -) +from homeassistant.const import ATTR_ENTITY_ID, SERVICE_LOCK, SERVICE_UNLOCK from homeassistant.core import HomeAssistant from tests.common import async_fire_time_changed @@ -29,7 +23,7 @@ async def test_lock_attributes( """Test lock attributes.""" lock = hass.states.get("lock.vault_door") assert lock is not None - assert lock.state == STATE_UNLOCKED + assert lock.state == LockState.UNLOCKED assert lock.attributes["changed_by"] == "thumbturn" mock_lock.is_locked = False @@ -40,7 +34,7 @@ async def test_lock_attributes( await hass.async_block_till_done(wait_background_tasks=True) lock = hass.states.get("lock.vault_door") assert lock is not None - assert lock.state == STATE_JAMMED + assert lock.state == LockState.JAMMED async def test_lock_services( diff --git a/tests/components/switch_as_x/__init__.py b/tests/components/switch_as_x/__init__.py index de6f1bac790..2addb832462 100644 --- a/tests/components/switch_as_x/__init__.py +++ b/tests/components/switch_as_x/__init__.py @@ -1,14 +1,7 @@ """The tests for Switch as X platforms.""" -from homeassistant.const import ( - STATE_CLOSED, - STATE_LOCKED, - STATE_OFF, - STATE_ON, - STATE_OPEN, - STATE_UNLOCKED, - Platform, -) +from homeassistant.components.lock import LockState +from homeassistant.const import STATE_CLOSED, STATE_OFF, STATE_ON, STATE_OPEN, Platform PLATFORMS_TO_TEST = ( Platform.COVER, @@ -24,7 +17,7 @@ STATE_MAP = { Platform.COVER: {STATE_ON: STATE_OPEN, STATE_OFF: STATE_CLOSED}, Platform.FAN: {STATE_ON: STATE_ON, STATE_OFF: STATE_OFF}, Platform.LIGHT: {STATE_ON: STATE_ON, STATE_OFF: STATE_OFF}, - Platform.LOCK: {STATE_ON: STATE_UNLOCKED, STATE_OFF: STATE_LOCKED}, + Platform.LOCK: {STATE_ON: LockState.UNLOCKED, STATE_OFF: LockState.LOCKED}, Platform.SIREN: {STATE_ON: STATE_ON, STATE_OFF: STATE_OFF}, Platform.VALVE: {STATE_ON: STATE_OPEN, STATE_OFF: STATE_CLOSED}, }, @@ -32,7 +25,7 @@ STATE_MAP = { Platform.COVER: {STATE_ON: STATE_CLOSED, STATE_OFF: STATE_OPEN}, Platform.FAN: {STATE_ON: STATE_ON, STATE_OFF: STATE_OFF}, Platform.LIGHT: {STATE_ON: STATE_ON, STATE_OFF: STATE_OFF}, - Platform.LOCK: {STATE_ON: STATE_LOCKED, STATE_OFF: STATE_UNLOCKED}, + Platform.LOCK: {STATE_ON: LockState.LOCKED, STATE_OFF: LockState.UNLOCKED}, Platform.SIREN: {STATE_ON: STATE_ON, STATE_OFF: STATE_OFF}, Platform.VALVE: {STATE_ON: STATE_CLOSED, STATE_OFF: STATE_OPEN}, }, diff --git a/tests/components/switch_as_x/test_init.py b/tests/components/switch_as_x/test_init.py index e250cacb7ac..cd80fab69bc 100644 --- a/tests/components/switch_as_x/test_init.py +++ b/tests/components/switch_as_x/test_init.py @@ -7,6 +7,7 @@ from unittest.mock import patch import pytest from homeassistant.components.homeassistant import exposed_entities +from homeassistant.components.lock import LockState from homeassistant.components.switch_as_x.config_flow import SwitchAsXConfigFlowHandler from homeassistant.components.switch_as_x.const import ( CONF_INVERT, @@ -17,11 +18,9 @@ from homeassistant.config_entries import ConfigEntryState from homeassistant.const import ( CONF_ENTITY_ID, STATE_CLOSED, - STATE_LOCKED, STATE_OFF, STATE_ON, STATE_OPEN, - STATE_UNLOCKED, EntityCategory, Platform, ) @@ -74,7 +73,7 @@ async def test_config_entry_unregistered_uuid( (Platform.COVER, STATE_OPEN, STATE_CLOSED), (Platform.FAN, STATE_ON, STATE_OFF), (Platform.LIGHT, STATE_ON, STATE_OFF), - (Platform.LOCK, STATE_UNLOCKED, STATE_LOCKED), + (Platform.LOCK, LockState.UNLOCKED, LockState.LOCKED), (Platform.SIREN, STATE_ON, STATE_OFF), (Platform.VALVE, STATE_OPEN, STATE_CLOSED), ], diff --git a/tests/components/switch_as_x/test_lock.py b/tests/components/switch_as_x/test_lock.py index f7d61cf6895..c2a0806778d 100644 --- a/tests/components/switch_as_x/test_lock.py +++ b/tests/components/switch_as_x/test_lock.py @@ -1,6 +1,6 @@ """Tests for the Switch as X Lock platform.""" -from homeassistant.components.lock import DOMAIN as LOCK_DOMAIN +from homeassistant.components.lock import DOMAIN as LOCK_DOMAIN, LockState from homeassistant.components.switch import DOMAIN as SWITCH_DOMAIN from homeassistant.components.switch_as_x.config_flow import SwitchAsXConfigFlowHandler from homeassistant.components.switch_as_x.const import ( @@ -15,10 +15,8 @@ from homeassistant.const import ( SERVICE_TURN_OFF, SERVICE_TURN_ON, SERVICE_UNLOCK, - STATE_LOCKED, STATE_OFF, STATE_ON, - STATE_UNLOCKED, Platform, ) from homeassistant.core import HomeAssistant @@ -70,7 +68,7 @@ async def test_service_calls(hass: HomeAssistant) -> None: assert await hass.config_entries.async_setup(config_entry.entry_id) await hass.async_block_till_done() - assert hass.states.get("lock.decorative_lights").state == STATE_UNLOCKED + assert hass.states.get("lock.decorative_lights").state == LockState.UNLOCKED await hass.services.async_call( LOCK_DOMAIN, @@ -80,7 +78,7 @@ async def test_service_calls(hass: HomeAssistant) -> None: ) assert hass.states.get("switch.decorative_lights").state == STATE_OFF - assert hass.states.get("lock.decorative_lights").state == STATE_LOCKED + assert hass.states.get("lock.decorative_lights").state == LockState.LOCKED await hass.services.async_call( LOCK_DOMAIN, @@ -90,7 +88,7 @@ async def test_service_calls(hass: HomeAssistant) -> None: ) assert hass.states.get("switch.decorative_lights").state == STATE_ON - assert hass.states.get("lock.decorative_lights").state == STATE_UNLOCKED + assert hass.states.get("lock.decorative_lights").state == LockState.UNLOCKED await hass.services.async_call( SWITCH_DOMAIN, @@ -100,7 +98,7 @@ async def test_service_calls(hass: HomeAssistant) -> None: ) assert hass.states.get("switch.decorative_lights").state == STATE_OFF - assert hass.states.get("lock.decorative_lights").state == STATE_LOCKED + assert hass.states.get("lock.decorative_lights").state == LockState.LOCKED await hass.services.async_call( SWITCH_DOMAIN, @@ -110,7 +108,7 @@ async def test_service_calls(hass: HomeAssistant) -> None: ) assert hass.states.get("switch.decorative_lights").state == STATE_ON - assert hass.states.get("lock.decorative_lights").state == STATE_UNLOCKED + assert hass.states.get("lock.decorative_lights").state == LockState.UNLOCKED await hass.services.async_call( SWITCH_DOMAIN, @@ -120,7 +118,7 @@ async def test_service_calls(hass: HomeAssistant) -> None: ) assert hass.states.get("switch.decorative_lights").state == STATE_OFF - assert hass.states.get("lock.decorative_lights").state == STATE_LOCKED + assert hass.states.get("lock.decorative_lights").state == LockState.LOCKED async def test_service_calls_inverted(hass: HomeAssistant) -> None: @@ -143,7 +141,7 @@ async def test_service_calls_inverted(hass: HomeAssistant) -> None: assert await hass.config_entries.async_setup(config_entry.entry_id) await hass.async_block_till_done() - assert hass.states.get("lock.decorative_lights").state == STATE_LOCKED + assert hass.states.get("lock.decorative_lights").state == LockState.LOCKED await hass.services.async_call( LOCK_DOMAIN, @@ -153,7 +151,7 @@ async def test_service_calls_inverted(hass: HomeAssistant) -> None: ) assert hass.states.get("switch.decorative_lights").state == STATE_ON - assert hass.states.get("lock.decorative_lights").state == STATE_LOCKED + assert hass.states.get("lock.decorative_lights").state == LockState.LOCKED await hass.services.async_call( LOCK_DOMAIN, @@ -163,7 +161,7 @@ async def test_service_calls_inverted(hass: HomeAssistant) -> None: ) assert hass.states.get("switch.decorative_lights").state == STATE_OFF - assert hass.states.get("lock.decorative_lights").state == STATE_UNLOCKED + assert hass.states.get("lock.decorative_lights").state == LockState.UNLOCKED await hass.services.async_call( SWITCH_DOMAIN, @@ -173,7 +171,7 @@ async def test_service_calls_inverted(hass: HomeAssistant) -> None: ) assert hass.states.get("switch.decorative_lights").state == STATE_OFF - assert hass.states.get("lock.decorative_lights").state == STATE_UNLOCKED + assert hass.states.get("lock.decorative_lights").state == LockState.UNLOCKED await hass.services.async_call( SWITCH_DOMAIN, @@ -183,7 +181,7 @@ async def test_service_calls_inverted(hass: HomeAssistant) -> None: ) assert hass.states.get("switch.decorative_lights").state == STATE_ON - assert hass.states.get("lock.decorative_lights").state == STATE_LOCKED + assert hass.states.get("lock.decorative_lights").state == LockState.LOCKED await hass.services.async_call( SWITCH_DOMAIN, @@ -193,4 +191,4 @@ async def test_service_calls_inverted(hass: HomeAssistant) -> None: ) assert hass.states.get("switch.decorative_lights").state == STATE_OFF - assert hass.states.get("lock.decorative_lights").state == STATE_UNLOCKED + assert hass.states.get("lock.decorative_lights").state == LockState.UNLOCKED diff --git a/tests/components/tedee/test_lock.py b/tests/components/tedee/test_lock.py index 741bc3156cb..d43cbccd48a 100644 --- a/tests/components/tedee/test_lock.py +++ b/tests/components/tedee/test_lock.py @@ -19,10 +19,7 @@ from homeassistant.components.lock import ( SERVICE_LOCK, SERVICE_OPEN, SERVICE_UNLOCK, - STATE_LOCKED, - STATE_LOCKING, - STATE_UNLOCKED, - STATE_UNLOCKING, + LockState, ) from homeassistant.components.webhook import async_generate_url from homeassistant.const import ATTR_ENTITY_ID, STATE_UNAVAILABLE, STATE_UNKNOWN @@ -75,7 +72,7 @@ async def test_lock( mock_tedee.lock.assert_called_once_with(12345) state = hass.states.get("lock.lock_1a2b") assert state - assert state.state == STATE_LOCKING + assert state.state == LockState.LOCKING await hass.services.async_call( LOCK_DOMAIN, @@ -90,7 +87,7 @@ async def test_lock( mock_tedee.unlock.assert_called_once_with(12345) state = hass.states.get("lock.lock_1a2b") assert state - assert state.state == STATE_UNLOCKING + assert state.state == LockState.UNLOCKING await hass.services.async_call( LOCK_DOMAIN, @@ -105,7 +102,7 @@ async def test_lock( mock_tedee.open.assert_called_once_with(12345) state = hass.states.get("lock.lock_1a2b") assert state - assert state.state == STATE_UNLOCKING + assert state.state == LockState.UNLOCKING async def test_lock_without_pullspring( @@ -279,7 +276,7 @@ async def test_new_lock( @pytest.mark.parametrize( ("lib_state", "expected_state"), [ - (TedeeLockState.LOCKED, STATE_LOCKED), + (TedeeLockState.LOCKED, LockState.LOCKED), (TedeeLockState.HALF_OPEN, STATE_UNKNOWN), (TedeeLockState.UNKNOWN, STATE_UNKNOWN), (TedeeLockState.UNCALIBRATED, STATE_UNAVAILABLE), @@ -296,7 +293,7 @@ async def test_webhook_update( state = hass.states.get("lock.lock_1a2b") assert state - assert state.state == STATE_UNLOCKED + assert state.state == LockState.UNLOCKED webhook_data = {"dummystate": lib_state.value} # is updated in the lib, so mock and assert below diff --git a/tests/components/template/test_lock.py b/tests/components/template/test_lock.py index f4e81cbfd63..c2b4960ca0e 100644 --- a/tests/components/template/test_lock.py +++ b/tests/components/template/test_lock.py @@ -4,6 +4,7 @@ import pytest from homeassistant import setup from homeassistant.components import lock +from homeassistant.components.lock import LockState from homeassistant.const import ( ATTR_CODE, ATTR_ENTITY_ID, @@ -71,13 +72,13 @@ async def test_template_state(hass: HomeAssistant, start_ha) -> None: await hass.async_block_till_done() state = hass.states.get("lock.test_template_lock") - assert state.state == lock.STATE_LOCKED + assert state.state == LockState.LOCKED hass.states.async_set("switch.test_state", STATE_OFF) await hass.async_block_till_done() state = hass.states.get("lock.test_template_lock") - assert state.state == lock.STATE_UNLOCKED + assert state.state == LockState.UNLOCKED @pytest.mark.parametrize(("count", "domain"), [(1, lock.DOMAIN)]) @@ -95,7 +96,7 @@ async def test_template_state(hass: HomeAssistant, start_ha) -> None: async def test_template_state_boolean_on(hass: HomeAssistant, start_ha) -> None: """Test the setting of the state with boolean on.""" state = hass.states.get("lock.template_lock") - assert state.state == lock.STATE_LOCKED + assert state.state == LockState.LOCKED @pytest.mark.parametrize(("count", "domain"), [(1, lock.DOMAIN)]) @@ -113,7 +114,7 @@ async def test_template_state_boolean_on(hass: HomeAssistant, start_ha) -> None: async def test_template_state_boolean_off(hass: HomeAssistant, start_ha) -> None: """Test the setting of the state with off.""" state = hass.states.get("lock.template_lock") - assert state.state == lock.STATE_UNLOCKED + assert state.state == LockState.UNLOCKED @pytest.mark.parametrize(("count", "domain"), [(0, lock.DOMAIN)]) @@ -200,12 +201,12 @@ async def test_template_syntax_error(hass: HomeAssistant, start_ha) -> None: async def test_template_static(hass: HomeAssistant, start_ha) -> None: """Test that we allow static templates.""" state = hass.states.get("lock.template_lock") - assert state.state == lock.STATE_UNLOCKED + assert state.state == LockState.UNLOCKED - hass.states.async_set("lock.template_lock", lock.STATE_LOCKED) + hass.states.async_set("lock.template_lock", LockState.LOCKED) await hass.async_block_till_done() state = hass.states.get("lock.template_lock") - assert state.state == lock.STATE_LOCKED + assert state.state == LockState.LOCKED @pytest.mark.parametrize(("count", "domain"), [(1, lock.DOMAIN)]) @@ -229,7 +230,7 @@ async def test_lock_action( await hass.async_block_till_done() state = hass.states.get("lock.template_lock") - assert state.state == lock.STATE_UNLOCKED + assert state.state == LockState.UNLOCKED await hass.services.async_call( lock.DOMAIN, @@ -264,7 +265,7 @@ async def test_unlock_action( await hass.async_block_till_done() state = hass.states.get("lock.template_lock") - assert state.state == lock.STATE_LOCKED + assert state.state == LockState.LOCKED await hass.services.async_call( lock.DOMAIN, @@ -300,7 +301,7 @@ async def test_lock_action_with_code( await hass.async_block_till_done() state = hass.states.get("lock.template_lock") - assert state.state == lock.STATE_UNLOCKED + assert state.state == LockState.UNLOCKED await hass.services.async_call( lock.DOMAIN, @@ -337,7 +338,7 @@ async def test_unlock_action_with_code( await hass.async_block_till_done() state = hass.states.get("lock.template_lock") - assert state.state == lock.STATE_LOCKED + assert state.state == LockState.LOCKED await hass.services.async_call( lock.DOMAIN, @@ -446,7 +447,7 @@ async def test_actions_with_none_as_codeformat_ignores_code( await hass.async_block_till_done() state = hass.states.get("lock.template_lock") - assert state.state == lock.STATE_UNLOCKED + assert state.state == LockState.UNLOCKED await hass.services.async_call( lock.DOMAIN, @@ -484,7 +485,7 @@ async def test_actions_with_invalid_regexp_as_codeformat_never_execute( await hass.async_block_till_done() state = hass.states.get("lock.template_lock") - assert state.state == lock.STATE_UNLOCKED + assert state.state == LockState.UNLOCKED await hass.services.async_call( lock.DOMAIN, @@ -519,7 +520,7 @@ async def test_actions_with_invalid_regexp_as_codeformat_never_execute( ], ) @pytest.mark.parametrize( - "test_state", [lock.STATE_UNLOCKING, lock.STATE_LOCKING, lock.STATE_JAMMED] + "test_state", [LockState.UNLOCKING, LockState.LOCKING, LockState.JAMMED] ) async def test_lock_state(hass: HomeAssistant, test_state, start_ha) -> None: """Test value template.""" diff --git a/tests/components/tesla_fleet/test_lock.py b/tests/components/tesla_fleet/test_lock.py index c576496284f..00b77aefcaf 100644 --- a/tests/components/tesla_fleet/test_lock.py +++ b/tests/components/tesla_fleet/test_lock.py @@ -10,14 +10,9 @@ from homeassistant.components.lock import ( DOMAIN as LOCK_DOMAIN, SERVICE_LOCK, SERVICE_UNLOCK, + LockState, ) -from homeassistant.const import ( - ATTR_ENTITY_ID, - STATE_LOCKED, - STATE_UNKNOWN, - STATE_UNLOCKED, - Platform, -) +from homeassistant.const import ATTR_ENTITY_ID, STATE_UNKNOWN, Platform from homeassistant.core import HomeAssistant from homeassistant.exceptions import ServiceValidationError from homeassistant.helpers import entity_registry as er @@ -74,7 +69,7 @@ async def test_lock_services( blocking=True, ) state = hass.states.get(entity_id) - assert state.state == STATE_LOCKED + assert state.state == LockState.LOCKED call.assert_called_once() with patch( @@ -88,7 +83,7 @@ async def test_lock_services( blocking=True, ) state = hass.states.get(entity_id) - assert state.state == STATE_UNLOCKED + assert state.state == LockState.UNLOCKED call.assert_called_once() entity_id = "lock.test_charge_cable_lock" @@ -112,5 +107,5 @@ async def test_lock_services( blocking=True, ) state = hass.states.get(entity_id) - assert state.state == STATE_UNLOCKED + assert state.state == LockState.UNLOCKED call.assert_called_once() diff --git a/tests/components/teslemetry/test_lock.py b/tests/components/teslemetry/test_lock.py index a50e97fe6ad..bd8e72a1df3 100644 --- a/tests/components/teslemetry/test_lock.py +++ b/tests/components/teslemetry/test_lock.py @@ -10,14 +10,9 @@ from homeassistant.components.lock import ( DOMAIN as LOCK_DOMAIN, SERVICE_LOCK, SERVICE_UNLOCK, + LockState, ) -from homeassistant.const import ( - ATTR_ENTITY_ID, - STATE_LOCKED, - STATE_UNKNOWN, - STATE_UNLOCKED, - Platform, -) +from homeassistant.const import ATTR_ENTITY_ID, STATE_UNKNOWN, Platform from homeassistant.core import HomeAssistant from homeassistant.exceptions import ServiceValidationError from homeassistant.helpers import entity_registry as er @@ -69,7 +64,7 @@ async def test_lock_services( blocking=True, ) state = hass.states.get(entity_id) - assert state.state == STATE_LOCKED + assert state.state == LockState.LOCKED call.assert_called_once() with patch( @@ -83,7 +78,7 @@ async def test_lock_services( blocking=True, ) state = hass.states.get(entity_id) - assert state.state == STATE_UNLOCKED + assert state.state == LockState.UNLOCKED call.assert_called_once() entity_id = "lock.test_charge_cable_lock" @@ -107,5 +102,5 @@ async def test_lock_services( blocking=True, ) state = hass.states.get(entity_id) - assert state.state == STATE_UNLOCKED + assert state.state == LockState.UNLOCKED call.assert_called_once() diff --git a/tests/components/tessie/test_lock.py b/tests/components/tessie/test_lock.py index cfb6168b399..43f8e23fb50 100644 --- a/tests/components/tessie/test_lock.py +++ b/tests/components/tessie/test_lock.py @@ -10,8 +10,9 @@ from homeassistant.components.lock import ( DOMAIN as LOCK_DOMAIN, SERVICE_LOCK, SERVICE_UNLOCK, + LockState, ) -from homeassistant.const import ATTR_ENTITY_ID, STATE_LOCKED, STATE_UNLOCKED, Platform +from homeassistant.const import ATTR_ENTITY_ID, Platform from homeassistant.core import HomeAssistant from homeassistant.exceptions import ServiceValidationError from homeassistant.helpers import entity_registry as er, issue_registry as ir @@ -49,7 +50,7 @@ async def test_locks( blocking=True, ) mock_run.assert_called_once() - assert hass.states.get(entity_id).state == STATE_LOCKED + assert hass.states.get(entity_id).state == LockState.LOCKED with patch("homeassistant.components.tessie.lock.unlock") as mock_run: await hass.services.async_call( @@ -59,7 +60,7 @@ async def test_locks( blocking=True, ) mock_run.assert_called_once() - assert hass.states.get(entity_id).state == STATE_UNLOCKED + assert hass.states.get(entity_id).state == LockState.UNLOCKED # Test charge cable lock set value functions entity_id = "lock.test_charge_cable_lock" @@ -80,7 +81,7 @@ async def test_locks( {ATTR_ENTITY_ID: [entity_id]}, blocking=True, ) - assert hass.states.get(entity_id).state == STATE_UNLOCKED + assert hass.states.get(entity_id).state == LockState.UNLOCKED mock_run.assert_called_once() @@ -119,7 +120,7 @@ async def test_speed_limit_lock( {ATTR_ENTITY_ID: [entity.entity_id], ATTR_CODE: "1234"}, blocking=True, ) - assert hass.states.get(entity.entity_id).state == STATE_LOCKED + assert hass.states.get(entity.entity_id).state == LockState.LOCKED mock_enable_speed_limit.assert_called_once() # Assert issue has been raised in the issue register assert issue_registry.async_get_issue(DOMAIN, "deprecated_speed_limit_locked") @@ -133,7 +134,7 @@ async def test_speed_limit_lock( {ATTR_ENTITY_ID: [entity.entity_id], ATTR_CODE: "1234"}, blocking=True, ) - assert hass.states.get(entity.entity_id).state == STATE_UNLOCKED + assert hass.states.get(entity.entity_id).state == LockState.UNLOCKED mock_disable_speed_limit.assert_called_once() assert issue_registry.async_get_issue(DOMAIN, "deprecated_speed_limit_unlocked") diff --git a/tests/components/unifiprotect/test_lock.py b/tests/components/unifiprotect/test_lock.py index 62a1cb9ff46..8b37b1c5928 100644 --- a/tests/components/unifiprotect/test_lock.py +++ b/tests/components/unifiprotect/test_lock.py @@ -6,16 +6,12 @@ from unittest.mock import AsyncMock, Mock from uiprotect.data import Doorlock, LockStatusType +from homeassistant.components.lock import LockState from homeassistant.components.unifiprotect.const import DEFAULT_ATTRIBUTION from homeassistant.const import ( ATTR_ATTRIBUTION, ATTR_ENTITY_ID, - STATE_JAMMED, - STATE_LOCKED, - STATE_LOCKING, STATE_UNAVAILABLE, - STATE_UNLOCKED, - STATE_UNLOCKING, Platform, ) from homeassistant.core import HomeAssistant @@ -64,7 +60,7 @@ async def test_lock_setup( state = hass.states.get(entity_id) assert state - assert state.state == STATE_UNLOCKED + assert state.state == LockState.UNLOCKED assert state.attributes[ATTR_ATTRIBUTION] == DEFAULT_ATTRIBUTION @@ -92,7 +88,7 @@ async def test_lock_locked( state = hass.states.get("lock.test_lock_lock") assert state - assert state.state == STATE_LOCKED + assert state.state == LockState.LOCKED async def test_lock_unlocking( @@ -119,7 +115,7 @@ async def test_lock_unlocking( state = hass.states.get("lock.test_lock_lock") assert state - assert state.state == STATE_UNLOCKING + assert state.state == LockState.UNLOCKING async def test_lock_locking( @@ -146,7 +142,7 @@ async def test_lock_locking( state = hass.states.get("lock.test_lock_lock") assert state - assert state.state == STATE_LOCKING + assert state.state == LockState.LOCKING async def test_lock_jammed( @@ -173,7 +169,7 @@ async def test_lock_jammed( state = hass.states.get("lock.test_lock_lock") assert state - assert state.state == STATE_JAMMED + assert state.state == LockState.JAMMED async def test_lock_unavailable( diff --git a/tests/components/vera/test_lock.py b/tests/components/vera/test_lock.py index 4139a494e1f..d24a0e1265f 100644 --- a/tests/components/vera/test_lock.py +++ b/tests/components/vera/test_lock.py @@ -4,7 +4,7 @@ from unittest.mock import MagicMock import pyvera as pv -from homeassistant.const import STATE_LOCKED, STATE_UNLOCKED +from homeassistant.components.lock import LockState from homeassistant.core import HomeAssistant from .common import ComponentFactory, new_simple_controller_config @@ -29,7 +29,7 @@ async def test_lock( ) update_callback = component_data.controller_data[0].update_callback - assert hass.states.get(entity_id).state == STATE_UNLOCKED + assert hass.states.get(entity_id).state == LockState.UNLOCKED await hass.services.async_call( "lock", @@ -41,7 +41,7 @@ async def test_lock( vera_device.is_locked.return_value = True update_callback(vera_device) await hass.async_block_till_done() - assert hass.states.get(entity_id).state == STATE_LOCKED + assert hass.states.get(entity_id).state == LockState.LOCKED await hass.services.async_call( "lock", @@ -53,4 +53,4 @@ async def test_lock( vera_device.is_locked.return_value = False update_callback(vera_device) await hass.async_block_till_done() - assert hass.states.get(entity_id).state == STATE_UNLOCKED + assert hass.states.get(entity_id).state == LockState.UNLOCKED diff --git a/tests/components/yale/test_init.py b/tests/components/yale/test_init.py index 4f0a853710c..c028924199e 100644 --- a/tests/components/yale/test_init.py +++ b/tests/components/yale/test_init.py @@ -6,7 +6,7 @@ from aiohttp import ClientResponseError import pytest from yalexs.exceptions import InvalidAuth, YaleApiError -from homeassistant.components.lock import DOMAIN as LOCK_DOMAIN +from homeassistant.components.lock import DOMAIN as LOCK_DOMAIN, LockState from homeassistant.components.yale.const import DOMAIN from homeassistant.config_entries import ConfigEntryState from homeassistant.const import ( @@ -14,7 +14,6 @@ from homeassistant.const import ( SERVICE_LOCK, SERVICE_OPEN, SERVICE_UNLOCK, - STATE_LOCKED, STATE_ON, ) from homeassistant.core import HomeAssistant @@ -151,7 +150,7 @@ async def test_inoperative_locks_are_filtered_out(hass: HomeAssistant) -> None: lock_a6697750d607098bae8d6baa11ef8063_name = hass.states.get( "lock.a6697750d607098bae8d6baa11ef8063_name" ) - assert lock_a6697750d607098bae8d6baa11ef8063_name.state == STATE_LOCKED + assert lock_a6697750d607098bae8d6baa11ef8063_name.state == LockState.LOCKED async def test_lock_has_doorsense(hass: HomeAssistant) -> None: diff --git a/tests/components/yale/test_lock.py b/tests/components/yale/test_lock.py index 2bbb7408953..f0fe018759c 100644 --- a/tests/components/yale/test_lock.py +++ b/tests/components/yale/test_lock.py @@ -8,21 +8,14 @@ import pytest from syrupy import SnapshotAssertion from yalexs.manager.activity import INITIAL_LOCK_RESYNC_TIME -from homeassistant.components.lock import ( - DOMAIN as LOCK_DOMAIN, - STATE_JAMMED, - STATE_LOCKING, - STATE_UNLOCKING, -) +from homeassistant.components.lock import DOMAIN as LOCK_DOMAIN, LockState from homeassistant.const import ( ATTR_ENTITY_ID, SERVICE_LOCK, SERVICE_OPEN, SERVICE_UNLOCK, - STATE_LOCKED, STATE_UNAVAILABLE, STATE_UNKNOWN, - STATE_UNLOCKED, ) from homeassistant.core import HomeAssistant from homeassistant.exceptions import HomeAssistantError @@ -62,7 +55,7 @@ async def test_lock_changed_by(hass: HomeAssistant) -> None: await _create_yale_with_devices(hass, [lock_one], activities=activities) lock_state = hass.states.get("lock.online_with_doorsense_name") - assert lock_state.state == STATE_LOCKED + assert lock_state.state == LockState.LOCKED assert lock_state.attributes["changed_by"] == "Your favorite elven princess" @@ -73,7 +66,7 @@ async def test_state_locking(hass: HomeAssistant) -> None: activities = await _mock_activities_from_fixture(hass, "get_activity.locking.json") await _create_yale_with_devices(hass, [lock_one], activities=activities) - assert hass.states.get("lock.online_with_doorsense_name").state == STATE_LOCKING + assert hass.states.get("lock.online_with_doorsense_name").state == LockState.LOCKING async def test_state_unlocking(hass: HomeAssistant) -> None: @@ -87,7 +80,7 @@ async def test_state_unlocking(hass: HomeAssistant) -> None: lock_online_with_doorsense_name = hass.states.get("lock.online_with_doorsense_name") - assert lock_online_with_doorsense_name.state == STATE_UNLOCKING + assert lock_online_with_doorsense_name.state == LockState.UNLOCKING async def test_state_jammed(hass: HomeAssistant) -> None: @@ -97,7 +90,7 @@ async def test_state_jammed(hass: HomeAssistant) -> None: activities = await _mock_activities_from_fixture(hass, "get_activity.jammed.json") await _create_yale_with_devices(hass, [lock_one], activities=activities) - assert hass.states.get("lock.online_with_doorsense_name").state == STATE_JAMMED + assert hass.states.get("lock.online_with_doorsense_name").state == LockState.JAMMED async def test_one_lock_operation( @@ -109,7 +102,7 @@ async def test_one_lock_operation( lock_state = hass.states.get("lock.online_with_doorsense_name") - assert lock_state.state == STATE_LOCKED + assert lock_state.state == LockState.LOCKED assert lock_state.attributes["battery_level"] == 92 assert lock_state.attributes["friendly_name"] == "online_with_doorsense Name" @@ -118,7 +111,7 @@ async def test_one_lock_operation( await hass.services.async_call(LOCK_DOMAIN, SERVICE_UNLOCK, data, blocking=True) lock_state = hass.states.get("lock.online_with_doorsense_name") - assert lock_state.state == STATE_UNLOCKED + assert lock_state.state == LockState.UNLOCKED assert lock_state.attributes["battery_level"] == 92 assert lock_state.attributes["friendly_name"] == "online_with_doorsense Name" @@ -126,7 +119,7 @@ async def test_one_lock_operation( await hass.services.async_call(LOCK_DOMAIN, SERVICE_LOCK, data, blocking=True) lock_state = hass.states.get("lock.online_with_doorsense_name") - assert lock_state.state == STATE_LOCKED + assert lock_state.state == LockState.LOCKED # No activity means it will be unavailable until the activity feed has data assert entity_registry.async_get("sensor.online_with_doorsense_name_operator") @@ -139,12 +132,12 @@ async def test_open_lock_operation(hass: HomeAssistant) -> None: lock_with_unlatch = await _mock_lock_with_unlatch(hass) await _create_yale_with_devices(hass, [lock_with_unlatch]) - assert hass.states.get("lock.online_with_unlatch_name").state == STATE_LOCKED + assert hass.states.get("lock.online_with_unlatch_name").state == LockState.LOCKED data = {ATTR_ENTITY_ID: "lock.online_with_unlatch_name"} await hass.services.async_call(LOCK_DOMAIN, SERVICE_OPEN, data, blocking=True) - assert hass.states.get("lock.online_with_unlatch_name").state == STATE_UNLOCKED + assert hass.states.get("lock.online_with_unlatch_name").state == LockState.UNLOCKED async def test_open_lock_operation_socketio_connected( @@ -159,7 +152,7 @@ async def test_open_lock_operation_socketio_connected( _, socketio = await _create_yale_with_devices(hass, [lock_with_unlatch]) socketio.connected = True - assert hass.states.get("lock.online_with_unlatch_name").state == STATE_LOCKED + assert hass.states.get("lock.online_with_unlatch_name").state == LockState.LOCKED data = {ATTR_ENTITY_ID: "lock.online_with_unlatch_name"} await hass.services.async_call(LOCK_DOMAIN, SERVICE_OPEN, data, blocking=True) @@ -176,7 +169,7 @@ async def test_open_lock_operation_socketio_connected( await hass.async_block_till_done() await hass.async_block_till_done() - assert hass.states.get("lock.online_with_unlatch_name").state == STATE_UNLOCKED + assert hass.states.get("lock.online_with_unlatch_name").state == LockState.UNLOCKED await hass.async_block_till_done() @@ -194,7 +187,7 @@ async def test_one_lock_operation_socketio_connected( socketio.connected = True lock_state = hass.states.get("lock.online_with_doorsense_name") - assert lock_state.state == STATE_LOCKED + assert lock_state.state == LockState.LOCKED assert lock_state.attributes["battery_level"] == 92 assert lock_state.attributes["friendly_name"] == "online_with_doorsense Name" @@ -214,7 +207,7 @@ async def test_one_lock_operation_socketio_connected( await hass.async_block_till_done() lock_state = states.get("lock.online_with_doorsense_name") - assert lock_state.state == STATE_UNLOCKED + assert lock_state.state == LockState.UNLOCKED assert lock_state.attributes["battery_level"] == 92 assert lock_state.attributes["friendly_name"] == "online_with_doorsense Name" @@ -231,7 +224,7 @@ async def test_one_lock_operation_socketio_connected( await hass.async_block_till_done() await hass.async_block_till_done() - assert states.get("lock.online_with_doorsense_name").state == STATE_LOCKED + assert states.get("lock.online_with_doorsense_name").state == LockState.LOCKED # No activity means it will be unavailable until the activity feed has data assert entity_registry.async_get("sensor.online_with_doorsense_name_operator") @@ -251,7 +244,7 @@ async def test_one_lock_operation_socketio_connected( await hass.async_block_till_done() - assert states.get("lock.online_with_doorsense_name").state == STATE_UNLOCKED + assert states.get("lock.online_with_doorsense_name").state == LockState.UNLOCKED async def test_lock_jammed(hass: HomeAssistant) -> None: @@ -271,14 +264,14 @@ async def test_lock_jammed(hass: HomeAssistant) -> None: states = hass.states lock_state = states.get("lock.online_with_doorsense_name") - assert lock_state.state == STATE_LOCKED + assert lock_state.state == LockState.LOCKED assert lock_state.attributes["battery_level"] == 92 assert lock_state.attributes["friendly_name"] == "online_with_doorsense Name" data = {ATTR_ENTITY_ID: "lock.online_with_doorsense_name"} await hass.services.async_call(LOCK_DOMAIN, SERVICE_UNLOCK, data, blocking=True) - assert states.get("lock.online_with_doorsense_name").state == STATE_JAMMED + assert states.get("lock.online_with_doorsense_name").state == LockState.JAMMED async def test_lock_throws_exception_on_unknown_status_code( @@ -299,7 +292,7 @@ async def test_lock_throws_exception_on_unknown_status_code( ) lock_state = hass.states.get("lock.online_with_doorsense_name") - assert lock_state.state == STATE_LOCKED + assert lock_state.state == LockState.LOCKED assert lock_state.attributes["battery_level"] == 92 assert lock_state.attributes["friendly_name"] == "online_with_doorsense Name" @@ -342,7 +335,7 @@ async def test_lock_bridge_online(hass: HomeAssistant) -> None: await _create_yale_with_devices(hass, [lock_one], activities=activities) states = hass.states - assert states.get("lock.online_with_doorsense_name").state == STATE_LOCKED + assert states.get("lock.online_with_doorsense_name").state == LockState.LOCKED async def test_lock_update_via_socketio(hass: HomeAssistant) -> None: @@ -357,7 +350,7 @@ async def test_lock_update_via_socketio(hass: HomeAssistant) -> None: socketio.connected = True states = hass.states - assert states.get("lock.online_with_doorsense_name").state == STATE_LOCKED + assert states.get("lock.online_with_doorsense_name").state == LockState.LOCKED listener = list(socketio._listeners)[0] listener( @@ -371,7 +364,7 @@ async def test_lock_update_via_socketio(hass: HomeAssistant) -> None: await hass.async_block_till_done() await hass.async_block_till_done() - assert states.get("lock.online_with_doorsense_name").state == STATE_UNLOCKING + assert states.get("lock.online_with_doorsense_name").state == LockState.UNLOCKING listener( lock_one.device_id, @@ -384,21 +377,21 @@ async def test_lock_update_via_socketio(hass: HomeAssistant) -> None: await hass.async_block_till_done() await hass.async_block_till_done() - assert states.get("lock.online_with_doorsense_name").state == STATE_LOCKING + assert states.get("lock.online_with_doorsense_name").state == LockState.LOCKING async_fire_time_changed(hass, dt_util.utcnow() + datetime.timedelta(seconds=30)) await hass.async_block_till_done() - assert states.get("lock.online_with_doorsense_name").state == STATE_LOCKING + assert states.get("lock.online_with_doorsense_name").state == LockState.LOCKING socketio.connected = True async_fire_time_changed(hass, dt_util.utcnow() + datetime.timedelta(seconds=30)) await hass.async_block_till_done() - assert states.get("lock.online_with_doorsense_name").state == STATE_LOCKING + assert states.get("lock.online_with_doorsense_name").state == LockState.LOCKING # Ensure socketio status is always preserved async_fire_time_changed(hass, dt_util.utcnow() + datetime.timedelta(hours=2)) await hass.async_block_till_done() - assert states.get("lock.online_with_doorsense_name").state == STATE_LOCKING + assert states.get("lock.online_with_doorsense_name").state == LockState.LOCKING listener( lock_one.device_id, @@ -411,11 +404,11 @@ async def test_lock_update_via_socketio(hass: HomeAssistant) -> None: await hass.async_block_till_done() await hass.async_block_till_done() - assert states.get("lock.online_with_doorsense_name").state == STATE_UNLOCKING + assert states.get("lock.online_with_doorsense_name").state == LockState.UNLOCKING async_fire_time_changed(hass, dt_util.utcnow() + datetime.timedelta(hours=4)) await hass.async_block_till_done() - assert states.get("lock.online_with_doorsense_name").state == STATE_UNLOCKING + assert states.get("lock.online_with_doorsense_name").state == LockState.UNLOCKING await hass.config_entries.async_unload(config_entry.entry_id) await hass.async_block_till_done() diff --git a/tests/components/zha/test_lock.py b/tests/components/zha/test_lock.py index 4e1d092af9b..dd4afb0ae14 100644 --- a/tests/components/zha/test_lock.py +++ b/tests/components/zha/test_lock.py @@ -8,14 +8,14 @@ from zigpy.zcl import Cluster from zigpy.zcl.clusters import closures, general import zigpy.zcl.foundation as zcl_f -from homeassistant.components.lock import DOMAIN as LOCK_DOMAIN +from homeassistant.components.lock import DOMAIN as LOCK_DOMAIN, LockState from homeassistant.components.zha.helpers import ( ZHADeviceProxy, ZHAGatewayProxy, get_zha_gateway, get_zha_gateway_proxy, ) -from homeassistant.const import STATE_LOCKED, STATE_UNLOCKED, Platform +from homeassistant.const import Platform from homeassistant.core import HomeAssistant from .common import find_entity_id, send_attributes_report @@ -65,7 +65,7 @@ async def test_lock(hass: HomeAssistant, setup_zha, zigpy_device_mock) -> None: cluster = zigpy_device.endpoints[1].door_lock assert entity_id is not None - assert hass.states.get(entity_id).state == STATE_UNLOCKED + assert hass.states.get(entity_id).state == LockState.UNLOCKED # set state to locked await send_attributes_report( @@ -73,7 +73,7 @@ async def test_lock(hass: HomeAssistant, setup_zha, zigpy_device_mock) -> None: cluster, {closures.DoorLock.AttributeDefs.lock_state.id: closures.LockState.Locked}, ) - assert hass.states.get(entity_id).state == STATE_LOCKED + assert hass.states.get(entity_id).state == LockState.LOCKED # set state to unlocked await send_attributes_report( @@ -81,7 +81,7 @@ async def test_lock(hass: HomeAssistant, setup_zha, zigpy_device_mock) -> None: cluster, {closures.DoorLock.AttributeDefs.lock_state.id: closures.LockState.Unlocked}, ) - assert hass.states.get(entity_id).state == STATE_UNLOCKED + assert hass.states.get(entity_id).state == LockState.UNLOCKED # lock from HA await async_lock(hass, cluster, entity_id) diff --git a/tests/components/zwave_js/test_lock.py b/tests/components/zwave_js/test_lock.py index 274444d813e..47e680570f0 100644 --- a/tests/components/zwave_js/test_lock.py +++ b/tests/components/zwave_js/test_lock.py @@ -15,6 +15,7 @@ from homeassistant.components.lock import ( DOMAIN as LOCK_DOMAIN, SERVICE_LOCK, SERVICE_UNLOCK, + LockState, ) from homeassistant.components.zwave_js.const import ( ATTR_LOCK_TIMEOUT, @@ -27,13 +28,7 @@ from homeassistant.components.zwave_js.lock import ( SERVICE_SET_LOCK_CONFIGURATION, SERVICE_SET_LOCK_USERCODE, ) -from homeassistant.const import ( - ATTR_ENTITY_ID, - STATE_LOCKED, - STATE_UNAVAILABLE, - STATE_UNKNOWN, - STATE_UNLOCKED, -) +from homeassistant.const import ATTR_ENTITY_ID, STATE_UNAVAILABLE, STATE_UNKNOWN from homeassistant.core import HomeAssistant from homeassistant.exceptions import HomeAssistantError @@ -52,7 +47,7 @@ async def test_door_lock( state = hass.states.get(SCHLAGE_BE469_LOCK_ENTITY) assert state - assert state.state == STATE_UNLOCKED + assert state.state == LockState.UNLOCKED # Test locking await hass.services.async_call( @@ -97,7 +92,7 @@ async def test_door_lock( state = hass.states.get(SCHLAGE_BE469_LOCK_ENTITY) assert state - assert state.state == STATE_LOCKED + assert state.state == LockState.LOCKED client.async_send_command.reset_mock() diff --git a/tests/helpers/test_state.py b/tests/helpers/test_state.py index 150f31f5fe9..ea7c1f6827f 100644 --- a/tests/helpers/test_state.py +++ b/tests/helpers/test_state.py @@ -5,18 +5,17 @@ from unittest.mock import patch import pytest +from homeassistant.components.lock import LockState from homeassistant.components.sun import STATE_ABOVE_HORIZON, STATE_BELOW_HORIZON from homeassistant.const import ( SERVICE_TURN_OFF, SERVICE_TURN_ON, STATE_CLOSED, STATE_HOME, - STATE_LOCKED, STATE_NOT_HOME, STATE_OFF, STATE_ON, STATE_OPEN, - STATE_UNLOCKED, ) from homeassistant.core import HomeAssistant, State from homeassistant.helpers import state @@ -143,11 +142,17 @@ async def test_as_number_states(hass: HomeAssistant) -> None: zero_states = ( STATE_OFF, STATE_CLOSED, - STATE_UNLOCKED, + LockState.UNLOCKED, STATE_BELOW_HORIZON, STATE_NOT_HOME, ) - one_states = (STATE_ON, STATE_OPEN, STATE_LOCKED, STATE_ABOVE_HORIZON, STATE_HOME) + one_states = ( + STATE_ON, + STATE_OPEN, + LockState.LOCKED, + STATE_ABOVE_HORIZON, + STATE_HOME, + ) for _state in zero_states: assert state.state_as_number(State("domain.test", _state, {})) == 0 for _state in one_states: diff --git a/tests/test_const.py b/tests/test_const.py index 64ccb875cf5..a370d0f28cd 100644 --- a/tests/test_const.py +++ b/tests/test_const.py @@ -5,7 +5,7 @@ from enum import Enum import pytest from homeassistant import const -from homeassistant.components import sensor +from homeassistant.components import lock, sensor from .common import ( help_test_all, @@ -182,3 +182,33 @@ def test_deprecated_constant_name_changes( replacement, "2025.1", ) + + +def _create_tuples_lock_states( + enum: type[Enum], constant_prefix: str, remove_in_version: str +) -> list[tuple[Enum, str]]: + return [ + (enum_field, constant_prefix, remove_in_version) + for enum_field in enum + if enum_field + not in [ + lock.LockState.OPEN, + lock.LockState.OPENING, + ] + ] + + +@pytest.mark.parametrize( + ("enum", "constant_prefix", "remove_in_version"), + _create_tuples_lock_states(lock.LockState, "STATE_", "2025.10"), +) +def test_deprecated_constants_lock( + caplog: pytest.LogCaptureFixture, + enum: Enum, + constant_prefix: str, + remove_in_version: str, +) -> None: + """Test deprecated constants.""" + import_and_test_deprecated_constant_enum( + caplog, const, enum, constant_prefix, remove_in_version + )