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

Change lock state to an enum (#126379)

Browse Source 
* Add new LockState enum for lock states

* Add rest

* Fix insteon tests

* Fix mqtt tests

* Fix tesla_fleet

* Revert back ST_STATE_LOCKED

* Add back constant
This commit is contained in:
G Johansson 2024-09-24 12:30:50 +02:00 committed by GitHub
parent 9297011731
commit 93aade6e8e
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
63 changed files with 710 additions and 812 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
homeassistant/components/alexa/capabilities.py
View File

@ -29,6 +29,7 @@ from homeassistant.components.alarm_control_panel import (
CodeFormat, CodeFormat,
) )
from homeassistant.components.climate import HVACMode from homeassistant.components.climate import HVACMode
from homeassistant.components.lock import LockState
from homeassistant.const import ( from homeassistant.const import (
ATTR_CODE_FORMAT, ATTR_CODE_FORMAT,
ATTR_SUPPORTED_FEATURES, ATTR_SUPPORTED_FEATURES,
@ -40,16 +41,12 @@ from homeassistant.const import (
STATE_ALARM_ARMED_HOME, STATE_ALARM_ARMED_HOME,
STATE_ALARM_ARMED_NIGHT, STATE_ALARM_ARMED_NIGHT,
STATE_IDLE, STATE_IDLE,
STATE_LOCKED,
STATE_LOCKING,
STATE_OFF, STATE_OFF,
STATE_ON, STATE_ON,
STATE_PAUSED, STATE_PAUSED,
STATE_PLAYING, STATE_PLAYING,
STATE_UNAVAILABLE, STATE_UNAVAILABLE,
STATE_UNKNOWN, STATE_UNKNOWN,
STATE_UNLOCKED,
STATE_UNLOCKING,
UnitOfLength, UnitOfLength,
UnitOfMass, UnitOfMass,
UnitOfTemperature, UnitOfTemperature,
@ -500,10 +497,10 @@ class AlexaLockController(AlexaCapability):
raise UnsupportedProperty(name) raise UnsupportedProperty(name)
# If its unlocking its still locked and not unlocked yet # 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" return "LOCKED"
# If its locking its still unlocked and not locked yet # 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 "UNLOCKED"
return "JAMMED" return "JAMMED"

45
homeassistant/components/demo/lock.py
View File

@ -5,17 +5,8 @@ from __future__ import annotations
import asyncio import asyncio
from typing import Any 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.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.core import HomeAssistant
from homeassistant.helpers.entity_platform import AddEntitiesCallback from homeassistant.helpers.entity_platform import AddEntitiesCallback
@ -30,10 +21,10 @@ async def async_setup_entry(
"""Set up the Demo config entry.""" """Set up the Demo config entry."""
async_add_entities( async_add_entities(
[ [
DemoLock("Front Door", STATE_LOCKED), DemoLock("Front Door", LockState.LOCKED),
DemoLock("Kitchen Door", STATE_UNLOCKED), DemoLock("Kitchen Door", LockState.UNLOCKED),
DemoLock("Poorly Installed Door", STATE_UNLOCKED, False, True), DemoLock("Poorly Installed Door", LockState.UNLOCKED, False, True),
DemoLock("Openable Lock", STATE_LOCKED, True), DemoLock("Openable Lock", LockState.LOCKED, True),
] ]
) )
@ -61,56 +52,56 @@ class DemoLock(LockEntity):
@property @property
def is_locking(self) -> bool: def is_locking(self) -> bool:
"""Return true if lock is locking.""" """Return true if lock is locking."""
return self._state == STATE_LOCKING return self._state == LockState.LOCKING
@property @property
def is_unlocking(self) -> bool: def is_unlocking(self) -> bool:
"""Return true if lock is unlocking.""" """Return true if lock is unlocking."""
return self._state == STATE_UNLOCKING return self._state == LockState.UNLOCKING
@property @property
def is_jammed(self) -> bool: def is_jammed(self) -> bool:
"""Return true if lock is jammed.""" """Return true if lock is jammed."""
return self._state == STATE_JAMMED return self._state == LockState.JAMMED
@property @property
def is_locked(self) -> bool: def is_locked(self) -> bool:
"""Return true if lock is locked.""" """Return true if lock is locked."""
return self._state == STATE_LOCKED return self._state == LockState.LOCKED
@property @property
def is_open(self) -> bool: def is_open(self) -> bool:
"""Return true if lock is open.""" """Return true if lock is open."""
return self._state == STATE_OPEN return self._state == LockState.OPEN
@property @property
def is_opening(self) -> bool: def is_opening(self) -> bool:
"""Return true if lock is opening.""" """Return true if lock is opening."""
return self._state == STATE_OPENING return self._state == LockState.OPENING
async def async_lock(self, **kwargs: Any) -> None: async def async_lock(self, **kwargs: Any) -> None:
"""Lock the device.""" """Lock the device."""
self._state = STATE_LOCKING self._state = LockState.LOCKING
self.async_write_ha_state() self.async_write_ha_state()
await asyncio.sleep(LOCK_UNLOCK_DELAY) await asyncio.sleep(LOCK_UNLOCK_DELAY)
if self._jam_on_operation: if self._jam_on_operation:
self._state = STATE_JAMMED self._state = LockState.JAMMED
else: else:
self._state = STATE_LOCKED self._state = LockState.LOCKED
self.async_write_ha_state() self.async_write_ha_state()
async def async_unlock(self, **kwargs: Any) -> None: async def async_unlock(self, **kwargs: Any) -> None:
"""Unlock the device.""" """Unlock the device."""
self._state = STATE_UNLOCKING self._state = LockState.UNLOCKING
self.async_write_ha_state() self.async_write_ha_state()
await asyncio.sleep(LOCK_UNLOCK_DELAY) await asyncio.sleep(LOCK_UNLOCK_DELAY)
self._state = STATE_UNLOCKED self._state = LockState.UNLOCKED
self.async_write_ha_state() self.async_write_ha_state()
async def async_open(self, **kwargs: Any) -> None: async def async_open(self, **kwargs: Any) -> None:
"""Open the door latch.""" """Open the door latch."""
self._state = STATE_OPENING self._state = LockState.OPENING
self.async_write_ha_state() self.async_write_ha_state()
await asyncio.sleep(LOCK_UNLOCK_DELAY) await asyncio.sleep(LOCK_UNLOCK_DELAY)
self._state = STATE_OPEN self._state = LockState.OPEN
self.async_write_ha_state() self.async_write_ha_state()

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

@ -40,7 +40,7 @@ from homeassistant.components.cover import CoverEntityFeature
from homeassistant.components.fan import FanEntityFeature from homeassistant.components.fan import FanEntityFeature
from homeassistant.components.humidifier import HumidifierEntityFeature from homeassistant.components.humidifier import HumidifierEntityFeature
from homeassistant.components.light import LightEntityFeature 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.media_player import MediaPlayerEntityFeature, MediaType
from homeassistant.components.vacuum import VacuumEntityFeature from homeassistant.components.vacuum import VacuumEntityFeature
from homeassistant.components.valve import ValveEntityFeature from homeassistant.components.valve import ValveEntityFeature
@ -71,7 +71,6 @@ from homeassistant.const import (
STATE_ALARM_PENDING, STATE_ALARM_PENDING,
STATE_ALARM_TRIGGERED, STATE_ALARM_TRIGGERED,
STATE_IDLE, STATE_IDLE,
STATE_LOCKED,
STATE_OFF, STATE_OFF,
STATE_ON, STATE_ON,
STATE_PAUSED, STATE_PAUSED,
@ -1524,11 +1523,11 @@ class LockUnlockTrait(_Trait):
def query_attributes(self) -> dict[str, Any]: def query_attributes(self) -> dict[str, Any]:
"""Return LockUnlock query attributes.""" """Return LockUnlock query attributes."""
if self.state.state == STATE_JAMMED: if self.state.state == LockState.JAMMED:
return {"isJammed": True} return {"isJammed": True}
# If its unlocking its not yet unlocked so we consider is locked # 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): async def execute(self, command, data, params, challenge):
"""Execute an LockUnlock command.""" """Execute an LockUnlock command."""

19
homeassistant/components/group/lock.py
View File

@ -12,6 +12,7 @@ from homeassistant.components.lock import (
PLATFORM_SCHEMA as LOCK_PLATFORM_SCHEMA, PLATFORM_SCHEMA as LOCK_PLATFORM_SCHEMA,
LockEntity, LockEntity,
LockEntityFeature, LockEntityFeature,
LockState,
) )
from homeassistant.config_entries import ConfigEntry from homeassistant.config_entries import ConfigEntry
from homeassistant.const import ( from homeassistant.const import (
@ -22,14 +23,8 @@ from homeassistant.const import (
SERVICE_LOCK, SERVICE_LOCK,
SERVICE_OPEN, SERVICE_OPEN,
SERVICE_UNLOCK, SERVICE_UNLOCK,
STATE_JAMMED,
STATE_LOCKED,
STATE_LOCKING,
STATE_OPEN,
STATE_OPENING,
STATE_UNAVAILABLE, STATE_UNAVAILABLE,
STATE_UNKNOWN, STATE_UNKNOWN,
STATE_UNLOCKING,
) )
from homeassistant.core import HomeAssistant, callback from homeassistant.core import HomeAssistant, callback
from homeassistant.helpers import config_validation as cv, entity_registry as er 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 self._attr_is_locked = None
else: else:
# Set attributes based on member states and let the lock entity sort out the correct state # 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_jammed = LockState.JAMMED in states
self._attr_is_locking = STATE_LOCKING in states self._attr_is_locking = LockState.LOCKING in states
self._attr_is_opening = STATE_OPENING in states self._attr_is_opening = LockState.OPENING in states
self._attr_is_open = STATE_OPEN in states self._attr_is_open = LockState.OPEN in states
self._attr_is_unlocking = STATE_UNLOCKING in states self._attr_is_unlocking = LockState.UNLOCKING in states
self._attr_is_locked = all(state == STATE_LOCKED for state 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) self._attr_available = any(state != STATE_UNAVAILABLE for state in states)

20
homeassistant/components/group/registry.py
View File

@ -9,6 +9,7 @@ from dataclasses import dataclass
from typing import Protocol from typing import Protocol
from homeassistant.components.climate import HVACMode 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.vacuum import STATE_CLEANING, STATE_ERROR, STATE_RETURNING
from homeassistant.components.water_heater import ( from homeassistant.components.water_heater import (
STATE_ECO, STATE_ECO,
@ -28,19 +29,14 @@ from homeassistant.const import (
STATE_CLOSED, STATE_CLOSED,
STATE_HOME, STATE_HOME,
STATE_IDLE, STATE_IDLE,
STATE_LOCKED,
STATE_LOCKING,
STATE_NOT_HOME, STATE_NOT_HOME,
STATE_OFF, STATE_OFF,
STATE_OK, STATE_OK,
STATE_ON, STATE_ON,
STATE_OPEN, STATE_OPEN,
STATE_OPENING,
STATE_PAUSED, STATE_PAUSED,
STATE_PLAYING, STATE_PLAYING,
STATE_PROBLEM, STATE_PROBLEM,
STATE_UNLOCKED,
STATE_UNLOCKING,
Platform, Platform,
) )
from homeassistant.core import HomeAssistant, callback 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.DEVICE_TRACKER: ({STATE_HOME}, STATE_HOME, STATE_NOT_HOME),
Platform.LOCK: ( Platform.LOCK: (
{ {
STATE_LOCKING, LockState.LOCKING,
STATE_OPEN, LockState.OPEN,
STATE_OPENING, LockState.OPENING,
STATE_UNLOCKED, LockState.UNLOCKED,
STATE_UNLOCKING, LockState.UNLOCKING,
}, },
STATE_UNLOCKED, LockState.UNLOCKED,
STATE_LOCKED, LockState.LOCKED,
), ),
Platform.MEDIA_PLAYER: ( Platform.MEDIA_PLAYER: (
{ {

50
homeassistant/components/homekit/type_locks.py
View File

@ -5,14 +5,7 @@ from typing import Any
from pyhap.const import CATEGORY_DOOR_LOCK from pyhap.const import CATEGORY_DOOR_LOCK
from homeassistant.components.lock import ( from homeassistant.components.lock import DOMAIN as LOCK_DOMAIN, LockState
DOMAIN as LOCK_DOMAIN,
STATE_JAMMED,
STATE_LOCKED,
STATE_LOCKING,
STATE_UNLOCKED,
STATE_UNLOCKING,
)
from homeassistant.const import ATTR_CODE, ATTR_ENTITY_ID, STATE_UNKNOWN from homeassistant.const import ATTR_CODE, ATTR_ENTITY_ID, STATE_UNKNOWN
from homeassistant.core import State, callback 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__) _LOGGER = logging.getLogger(__name__)
HASS_TO_HOMEKIT_CURRENT = { HASS_TO_HOMEKIT_CURRENT = {
STATE_UNLOCKED: 0, LockState.UNLOCKED.value: 0,
STATE_UNLOCKING: 1, LockState.UNLOCKING.value: 1,
STATE_LOCKING: 0, LockState.LOCKING.value: 0,
STATE_LOCKED: 1, LockState.LOCKED.value: 1,
STATE_JAMMED: 2, LockState.JAMMED.value: 2,
STATE_UNKNOWN: 3, STATE_UNKNOWN: 3,
} }
HASS_TO_HOMEKIT_TARGET = { HASS_TO_HOMEKIT_TARGET = {
STATE_UNLOCKED: 0, LockState.UNLOCKED.value: 0,
STATE_UNLOCKING: 0, LockState.UNLOCKING.value: 0,
STATE_LOCKING: 1, LockState.LOCKING.value: 1,
STATE_LOCKED: 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 = { HOMEKIT_TO_HASS = {
0: STATE_UNLOCKED, 0: LockState.UNLOCKED.value,
1: STATE_LOCKED, 1: LockState.LOCKED.value,
2: STATE_JAMMED, 2: LockState.JAMMED.value,
3: STATE_UNKNOWN, 3: STATE_UNKNOWN,
} }
STATE_TO_SERVICE = { STATE_TO_SERVICE = {
STATE_LOCKING: "unlock", LockState.LOCKING.value: "unlock",
STATE_LOCKED: "lock", LockState.LOCKED.value: "lock",
STATE_UNLOCKING: "lock", LockState.UNLOCKING.value: "lock",
STATE_UNLOCKED: "unlock", LockState.UNLOCKED.value: "unlock",
} }
@ -74,7 +72,7 @@ class Lock(HomeAccessory):
) )
self.char_target_state = serv_lock_mechanism.configure_char( self.char_target_state = serv_lock_mechanism.configure_char(
CHAR_LOCK_TARGET_STATE, CHAR_LOCK_TARGET_STATE,
value=HASS_TO_HOMEKIT_CURRENT[STATE_LOCKED], value=HASS_TO_HOMEKIT_CURRENT[LockState.LOCKED.value],
setter_callback=self.set_state, setter_callback=self.set_state,
) )
self.async_update_state(state) self.async_update_state(state)

36
homeassistant/components/homekit_controller/lock.py
View File

@ -7,15 +7,9 @@ from typing import Any
from aiohomekit.model.characteristics import CharacteristicsTypes from aiohomekit.model.characteristics import CharacteristicsTypes
from aiohomekit.model.services import Service, ServicesTypes 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.config_entries import ConfigEntry
from homeassistant.const import ( from homeassistant.const import ATTR_BATTERY_LEVEL, STATE_UNKNOWN, Platform
ATTR_BATTERY_LEVEL,
STATE_LOCKED,
STATE_UNKNOWN,
STATE_UNLOCKED,
Platform,
)
from homeassistant.core import HomeAssistant, callback from homeassistant.core import HomeAssistant, callback
from homeassistant.helpers.entity_platform import AddEntitiesCallback from homeassistant.helpers.entity_platform import AddEntitiesCallback
@ -24,13 +18,13 @@ from .connection import HKDevice
from .entity import HomeKitEntity from .entity import HomeKitEntity
CURRENT_STATE_MAP = { CURRENT_STATE_MAP = {
0: STATE_UNLOCKED, 0: LockState.UNLOCKED,
1: STATE_LOCKED, 1: LockState.LOCKED,
2: STATE_JAMMED, 2: LockState.JAMMED,
3: STATE_UNKNOWN, 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()} 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) value = self.service.value(CharacteristicsTypes.LOCK_MECHANISM_CURRENT_STATE)
if CURRENT_STATE_MAP[value] == STATE_UNKNOWN: if CURRENT_STATE_MAP[value] == STATE_UNKNOWN:
return None return None
return CURRENT_STATE_MAP[value] == STATE_LOCKED return CURRENT_STATE_MAP[value] == LockState.LOCKED
@property @property
def is_locking(self) -> bool: def is_locking(self) -> bool:
@ -88,8 +82,8 @@ class HomeKitLock(HomeKitEntity, LockEntity):
CharacteristicsTypes.LOCK_MECHANISM_TARGET_STATE CharacteristicsTypes.LOCK_MECHANISM_TARGET_STATE
) )
return ( return (
CURRENT_STATE_MAP[current_value] == STATE_UNLOCKED CURRENT_STATE_MAP[current_value] == LockState.UNLOCKED
and REVERSED_TARGET_STATE_MAP.get(target_value) == STATE_LOCKED and REVERSED_TARGET_STATE_MAP.get(target_value) == LockState.LOCKED
) )
@property @property
@ -102,25 +96,25 @@ class HomeKitLock(HomeKitEntity, LockEntity):
CharacteristicsTypes.LOCK_MECHANISM_TARGET_STATE CharacteristicsTypes.LOCK_MECHANISM_TARGET_STATE
) )
return ( return (
CURRENT_STATE_MAP[current_value] == STATE_LOCKED CURRENT_STATE_MAP[current_value] == LockState.LOCKED
and REVERSED_TARGET_STATE_MAP.get(target_value) == STATE_UNLOCKED and REVERSED_TARGET_STATE_MAP.get(target_value) == LockState.UNLOCKED
) )
@property @property
def is_jammed(self) -> bool: def is_jammed(self) -> bool:
"""Return true if device is jammed.""" """Return true if device is jammed."""
value = self.service.value(CharacteristicsTypes.LOCK_MECHANISM_CURRENT_STATE) 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: async def async_lock(self, **kwargs: Any) -> None:
"""Lock the device.""" """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: async def async_unlock(self, **kwargs: Any) -> None:
"""Unlock the device.""" """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.""" """Send state command."""
await self.async_put_characteristics( await self.async_put_characteristics(
{CharacteristicsTypes.LOCK_MECHANISM_TARGET_STATE: TARGET_STATE_MAP[state]} {CharacteristicsTypes.LOCK_MECHANISM_TARGET_STATE: TARGET_STATE_MAP[state]}

7
homeassistant/components/isy994/const.py
View File

@ -15,6 +15,7 @@ from homeassistant.components.climate import (
HVACAction, HVACAction,
HVACMode, HVACMode,
) )
from homeassistant.components.lock import LockState
from homeassistant.const import ( from homeassistant.const import (
CONCENTRATION_MICROGRAMS_PER_CUBIC_METER, CONCENTRATION_MICROGRAMS_PER_CUBIC_METER,
CONCENTRATION_PARTS_PER_MILLION, CONCENTRATION_PARTS_PER_MILLION,
@ -29,14 +30,12 @@ from homeassistant.const import (
SIGNAL_STRENGTH_DECIBELS_MILLIWATT, SIGNAL_STRENGTH_DECIBELS_MILLIWATT,
STATE_CLOSED, STATE_CLOSED,
STATE_CLOSING, STATE_CLOSING,
STATE_LOCKED,
STATE_OFF, STATE_OFF,
STATE_ON, STATE_ON,
STATE_OPEN, STATE_OPEN,
STATE_OPENING, STATE_OPENING,
STATE_PROBLEM, STATE_PROBLEM,
STATE_UNKNOWN, STATE_UNKNOWN,
STATE_UNLOCKED,
UV_INDEX, UV_INDEX,
Platform, Platform,
UnitOfApparentPower, UnitOfApparentPower,
@ -451,8 +450,8 @@ UOM_FRIENDLY_NAME = {
UOM_TO_STATES = { UOM_TO_STATES = {
"11": { # Deadbolt Status "11": { # Deadbolt Status
0: STATE_UNLOCKED, 0: LockState.UNLOCKED,
100: STATE_LOCKED, 100: LockState.LOCKED,
101: STATE_UNKNOWN, 101: STATE_UNKNOWN,
102: STATE_PROBLEM, 102: STATE_PROBLEM,
}, },

21
homeassistant/components/kitchen_sink/lock.py
View File

@ -4,9 +4,8 @@ from __future__ import annotations
from typing import Any 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.config_entries import ConfigEntry
from homeassistant.const import STATE_LOCKED, STATE_OPEN, STATE_UNLOCKED
from homeassistant.core import HomeAssistant from homeassistant.core import HomeAssistant
from homeassistant.helpers.entity_platform import AddEntitiesCallback from homeassistant.helpers.entity_platform import AddEntitiesCallback
from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType
@ -24,24 +23,24 @@ async def async_setup_platform(
DemoLock( DemoLock(
"kitchen_sink_lock_001", "kitchen_sink_lock_001",
"Openable lock", "Openable lock",
STATE_LOCKED, LockState.LOCKED,
LockEntityFeature.OPEN, LockEntityFeature.OPEN,
), ),
DemoLock( DemoLock(
"kitchen_sink_lock_002", "kitchen_sink_lock_002",
"Another openable lock", "Another openable lock",
STATE_UNLOCKED, LockState.UNLOCKED,
LockEntityFeature.OPEN, LockEntityFeature.OPEN,
), ),
DemoLock( DemoLock(
"kitchen_sink_lock_003", "kitchen_sink_lock_003",
"Basic lock", "Basic lock",
STATE_LOCKED, LockState.LOCKED,
), ),
DemoLock( DemoLock(
"kitchen_sink_lock_004", "kitchen_sink_lock_004",
"Another basic lock", "Another basic lock",
STATE_UNLOCKED, LockState.UNLOCKED,
), ),
] ]
) )
@ -77,19 +76,19 @@ class DemoLock(LockEntity):
@property @property
def is_locked(self) -> bool: def is_locked(self) -> bool:
"""Return true if lock is locked.""" """Return true if lock is locked."""
return self._state == STATE_LOCKED return self._state == LockState.LOCKED
@property @property
def is_open(self) -> bool: def is_open(self) -> bool:
"""Return true if lock is open.""" """Return true if lock is open."""
return self._state == STATE_OPEN return self._state == LockState.OPEN
async def async_lock(self, **kwargs: Any) -> None: async def async_lock(self, **kwargs: Any) -> None:
"""Lock the device.""" """Lock the device."""
self._attr_is_locking = True self._attr_is_locking = True
self.async_write_ha_state() self.async_write_ha_state()
self._attr_is_locking = False self._attr_is_locking = False
self._state = STATE_LOCKED self._state = LockState.LOCKED
self.async_write_ha_state() self.async_write_ha_state()
async def async_unlock(self, **kwargs: Any) -> None: async def async_unlock(self, **kwargs: Any) -> None:
@ -97,10 +96,10 @@ class DemoLock(LockEntity):
self._attr_is_unlocking = True self._attr_is_unlocking = True
self.async_write_ha_state() self.async_write_ha_state()
self._attr_is_unlocking = False self._attr_is_unlocking = False
self._state = STATE_UNLOCKED self._state = LockState.UNLOCKED
self.async_write_ha_state() self.async_write_ha_state()
async def async_open(self, **kwargs: Any) -> None: async def async_open(self, **kwargs: Any) -> None:
"""Open the door latch.""" """Open the door latch."""
self._state = STATE_OPEN self._state = LockState.OPEN
self.async_write_ha_state() self.async_write_ha_state()

11
homeassistant/components/kiwi/lock.py
View File

@ -11,6 +11,7 @@ import voluptuous as vol
from homeassistant.components.lock import ( from homeassistant.components.lock import (
PLATFORM_SCHEMA as LOCK_PLATFORM_SCHEMA, PLATFORM_SCHEMA as LOCK_PLATFORM_SCHEMA,
LockEntity, LockEntity,
LockState,
) )
from homeassistant.const import ( from homeassistant.const import (
ATTR_ID, ATTR_ID,
@ -18,8 +19,6 @@ from homeassistant.const import (
ATTR_LONGITUDE, ATTR_LONGITUDE,
CONF_PASSWORD, CONF_PASSWORD,
CONF_USERNAME, CONF_USERNAME,
STATE_LOCKED,
STATE_UNLOCKED,
) )
from homeassistant.core import HomeAssistant, callback from homeassistant.core import HomeAssistant, callback
import homeassistant.helpers.config_validation as cv import homeassistant.helpers.config_validation as cv
@ -68,7 +67,7 @@ class KiwiLock(LockEntity):
self._sensor = kiwi_lock self._sensor = kiwi_lock
self._client = client self._client = client
self.lock_id = kiwi_lock["sensor_id"] self.lock_id = kiwi_lock["sensor_id"]
self._state = STATE_LOCKED self._state = LockState.LOCKED
address = kiwi_lock.get("address") address = kiwi_lock.get("address")
address.update( address.update(
@ -96,7 +95,7 @@ class KiwiLock(LockEntity):
@property @property
def is_locked(self) -> bool: def is_locked(self) -> bool:
"""Return true if lock is locked.""" """Return true if lock is locked."""
return self._state == STATE_LOCKED return self._state == LockState.LOCKED
@property @property
def extra_state_attributes(self) -> dict[str, Any]: def extra_state_attributes(self) -> dict[str, Any]:
@ -106,7 +105,7 @@ class KiwiLock(LockEntity):
@callback @callback
def clear_unlock_state(self, _): def clear_unlock_state(self, _):
"""Clear unlock state automatically.""" """Clear unlock state automatically."""
self._state = STATE_LOCKED self._state = LockState.LOCKED
self.async_write_ha_state() self.async_write_ha_state()
def unlock(self, **kwargs: Any) -> None: def unlock(self, **kwargs: Any) -> None:
@ -117,7 +116,7 @@ class KiwiLock(LockEntity):
except KiwiException: except KiwiException:
_LOGGER.error("Failed to open door") _LOGGER.error("Failed to open door")
else: else:
self._state = STATE_UNLOCKED self._state = LockState.UNLOCKED
self.hass.add_job( self.hass.add_job(
async_call_later, async_call_later,
self.hass, self.hass,

26
homeassistant/components/lock/__init__.py
View File

@ -13,19 +13,19 @@ from typing import TYPE_CHECKING, Any, final
import voluptuous as vol import voluptuous as vol
from homeassistant.config_entries import ConfigEntry 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,
ATTR_CODE_FORMAT, ATTR_CODE_FORMAT,
SERVICE_LOCK, SERVICE_LOCK,
SERVICE_OPEN, SERVICE_OPEN,
SERVICE_UNLOCK, SERVICE_UNLOCK,
STATE_JAMMED,
STATE_LOCKED,
STATE_LOCKING,
STATE_OPEN, STATE_OPEN,
STATE_OPENING, STATE_OPENING,
STATE_UNLOCKED,
STATE_UNLOCKING,
) )
from homeassistant.core import HomeAssistant, callback from homeassistant.core import HomeAssistant, callback
from homeassistant.exceptions import ServiceValidationError 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.helpers.typing import ConfigType, StateType
from homeassistant.util.hass_dict import HassKey from homeassistant.util.hass_dict import HassKey
from .const import DOMAIN from .const import DOMAIN, LockState
_LOGGER = logging.getLogger(__name__) _LOGGER = logging.getLogger(__name__)
@ -274,18 +274,18 @@ class LockEntity(Entity, cached_properties=CACHED_PROPERTIES_WITH_ATTR_):
def state(self) -> str | None: def state(self) -> str | None:
"""Return the state.""" """Return the state."""
if self.is_jammed: if self.is_jammed:
return STATE_JAMMED return LockState.JAMMED
if self.is_opening: if self.is_opening:
return STATE_OPENING return LockState.OPENING
if self.is_locking: if self.is_locking:
return STATE_LOCKING return LockState.LOCKING
if self.is_open: if self.is_open:
return STATE_OPEN return LockState.OPEN
if self.is_unlocking: if self.is_unlocking:
return STATE_UNLOCKING return LockState.UNLOCKING
if (locked := self.is_locked) is None: if (locked := self.is_locked) is None:
return None return None
return STATE_LOCKED if locked else STATE_UNLOCKED return LockState.LOCKED if locked else LockState.UNLOCKED
@cached_property @cached_property
def supported_features(self) -> LockEntityFeature: def supported_features(self) -> LockEntityFeature:

14
homeassistant/components/lock/const.py
View File

@ -1,3 +1,17 @@
"""Constants for the lock entity platform.""" """Constants for the lock entity platform."""
from enum import StrEnum
DOMAIN = "lock" DOMAIN = "lock"
class LockState(StrEnum):
"""State of lock entities."""
JAMMED = "jammed"
OPENING = "opening"
LOCKING = "locking"
OPEN = "open"
UNLOCKING = "unlocking"
LOCKED = "locked"
UNLOCKED = "unlocked"

23
homeassistant/components/lock/device_condition.py
View File

@ -11,13 +11,6 @@ from homeassistant.const import (
CONF_DOMAIN, CONF_DOMAIN,
CONF_ENTITY_ID, CONF_ENTITY_ID,
CONF_TYPE, CONF_TYPE,
STATE_JAMMED,
STATE_LOCKED,
STATE_LOCKING,
STATE_OPEN,
STATE_OPENING,
STATE_UNLOCKED,
STATE_UNLOCKING,
) )
from homeassistant.core import HomeAssistant, callback from homeassistant.core import HomeAssistant, callback
from homeassistant.helpers import ( 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.config_validation import DEVICE_CONDITION_BASE_SCHEMA
from homeassistant.helpers.typing import ConfigType, TemplateVarsType from homeassistant.helpers.typing import ConfigType, TemplateVarsType
from . import DOMAIN from . import DOMAIN, LockState
# mypy: disallow-any-generics # mypy: disallow-any-generics
@ -81,19 +74,19 @@ def async_condition_from_config(
) -> condition.ConditionCheckerType: ) -> condition.ConditionCheckerType:
"""Create a function to test a device condition.""" """Create a function to test a device condition."""
if config[CONF_TYPE] == "is_jammed": if config[CONF_TYPE] == "is_jammed":
state = STATE_JAMMED state = LockState.JAMMED
elif config[CONF_TYPE] == "is_opening": elif config[CONF_TYPE] == "is_opening":
state = STATE_OPENING state = LockState.OPENING
elif config[CONF_TYPE] == "is_locking": elif config[CONF_TYPE] == "is_locking":
state = STATE_LOCKING state = LockState.LOCKING
elif config[CONF_TYPE] == "is_open": elif config[CONF_TYPE] == "is_open":
state = STATE_OPEN state = LockState.OPEN
elif config[CONF_TYPE] == "is_unlocking": elif config[CONF_TYPE] == "is_unlocking":
state = STATE_UNLOCKING state = LockState.UNLOCKING
elif config[CONF_TYPE] == "is_locked": elif config[CONF_TYPE] == "is_locked":
state = STATE_LOCKED state = LockState.LOCKED
else: else:
state = STATE_UNLOCKED state = LockState.UNLOCKED
registry = er.async_get(hass) registry = er.async_get(hass)
entity_id = er.async_resolve_entity_id(registry, config[ATTR_ENTITY_ID]) entity_id = er.async_resolve_entity_id(registry, config[ATTR_ENTITY_ID])

23
homeassistant/components/lock/device_trigger.py
View File

@ -13,20 +13,13 @@ from homeassistant.const import (
CONF_FOR, CONF_FOR,
CONF_PLATFORM, CONF_PLATFORM,
CONF_TYPE, 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.core import CALLBACK_TYPE, HomeAssistant
from homeassistant.helpers import config_validation as cv, entity_registry as er from homeassistant.helpers import config_validation as cv, entity_registry as er
from homeassistant.helpers.trigger import TriggerActionType, TriggerInfo from homeassistant.helpers.trigger import TriggerActionType, TriggerInfo
from homeassistant.helpers.typing import ConfigType from homeassistant.helpers.typing import ConfigType
from . import DOMAIN from . import DOMAIN, LockState
TRIGGER_TYPES = { TRIGGER_TYPES = {
"jammed", "jammed",
@ -93,19 +86,19 @@ async def async_attach_trigger(
) -> CALLBACK_TYPE: ) -> CALLBACK_TYPE:
"""Attach a trigger.""" """Attach a trigger."""
if config[CONF_TYPE] == "jammed": if config[CONF_TYPE] == "jammed":
to_state = STATE_JAMMED to_state = LockState.JAMMED
elif config[CONF_TYPE] == "opening": elif config[CONF_TYPE] == "opening":
to_state = STATE_OPENING to_state = LockState.OPENING
elif config[CONF_TYPE] == "locking": elif config[CONF_TYPE] == "locking":
to_state = STATE_LOCKING to_state = LockState.LOCKING
elif config[CONF_TYPE] == "open": elif config[CONF_TYPE] == "open":
to_state = STATE_OPEN to_state = LockState.OPEN
elif config[CONF_TYPE] == "unlocking": elif config[CONF_TYPE] == "unlocking":
to_state = STATE_UNLOCKING to_state = LockState.UNLOCKING
elif config[CONF_TYPE] == "locked": elif config[CONF_TYPE] == "locked":
to_state = STATE_LOCKED to_state = LockState.LOCKED
else: else:
to_state = STATE_UNLOCKED to_state = LockState.UNLOCKED
state_config = { state_config = {
CONF_PLATFORM: "state", CONF_PLATFORM: "state",

26
homeassistant/components/lock/reproduce_state.py
View File

@ -12,26 +12,20 @@ from homeassistant.const import (
SERVICE_LOCK, SERVICE_LOCK,
SERVICE_OPEN, SERVICE_OPEN,
SERVICE_UNLOCK, SERVICE_UNLOCK,
STATE_LOCKED,
STATE_LOCKING,
STATE_OPEN,
STATE_OPENING,
STATE_UNLOCKED,
STATE_UNLOCKING,
) )
from homeassistant.core import Context, HomeAssistant, State from homeassistant.core import Context, HomeAssistant, State
from . import DOMAIN from . import DOMAIN, LockState
_LOGGER = logging.getLogger(__name__) _LOGGER = logging.getLogger(__name__)
VALID_STATES = { VALID_STATES = {
STATE_LOCKED, LockState.LOCKED,
STATE_LOCKING, LockState.LOCKING,
STATE_OPEN, LockState.OPEN,
STATE_OPENING, LockState.OPENING,
STATE_UNLOCKED, LockState.UNLOCKED,
STATE_UNLOCKING, LockState.UNLOCKING,
} }
@ -59,11 +53,11 @@ async def _async_reproduce_state(
service_data = {ATTR_ENTITY_ID: state.entity_id} 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 service = SERVICE_LOCK
elif state.state in {STATE_UNLOCKED, STATE_UNLOCKING}: elif state.state in {LockState.UNLOCKED, LockState.UNLOCKING}:
service = SERVICE_UNLOCK service = SERVICE_UNLOCK
elif state.state in {STATE_OPEN, STATE_OPENING}: elif state.state in {LockState.OPEN, LockState.OPENING}:
service = SERVICE_OPEN service = SERVICE_OPEN
await hass.services.async_call( await hass.services.async_call(

19
homeassistant/components/surepetcare/lock.py
View File

@ -5,11 +5,10 @@ from __future__ import annotations
from typing import Any from typing import Any
from surepy.entities import SurepyEntity 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.config_entries import ConfigEntry
from homeassistant.const import STATE_LOCKED, STATE_UNLOCKED
from homeassistant.core import HomeAssistant, callback from homeassistant.core import HomeAssistant, callback
from homeassistant.helpers.entity_platform import AddEntitiesCallback from homeassistant.helpers.entity_platform import AddEntitiesCallback
@ -30,9 +29,9 @@ async def async_setup_entry(
for surepy_entity in coordinator.data.values() for surepy_entity in coordinator.data.values()
if surepy_entity.type in [EntityType.CAT_FLAP, EntityType.PET_FLAP] if surepy_entity.type in [EntityType.CAT_FLAP, EntityType.PET_FLAP]
for lock_state in ( for lock_state in (
LockState.LOCKED_IN, SurepyLockState.LOCKED_IN,
LockState.LOCKED_OUT, SurepyLockState.LOCKED_OUT,
LockState.LOCKED_ALL, SurepyLockState.LOCKED_ALL,
) )
) )
@ -44,7 +43,7 @@ class SurePetcareLock(SurePetcareEntity, LockEntity):
self, self,
surepetcare_id: int, surepetcare_id: int,
coordinator: SurePetcareDataCoordinator, coordinator: SurePetcareDataCoordinator,
lock_state: LockState, lock_state: SurepyLockState,
) -> None: ) -> None:
"""Initialize a Sure Petcare lock.""" """Initialize a Sure Petcare lock."""
self._lock_state = lock_state.name.lower() self._lock_state = lock_state.name.lower()
@ -66,14 +65,14 @@ class SurePetcareLock(SurePetcareEntity, LockEntity):
status = surepy_entity.raw_data()["status"] status = surepy_entity.raw_data()["status"]
self._attr_is_locked = ( 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")) self._available = bool(status.get("online"))
async def async_lock(self, **kwargs: Any) -> None: async def async_lock(self, **kwargs: Any) -> None:
"""Lock the lock.""" """Lock the lock."""
if self.state != STATE_UNLOCKED: if self.state != LockState.UNLOCKED:
return return
self._attr_is_locking = True self._attr_is_locking = True
self.async_write_ha_state() self.async_write_ha_state()
@ -87,7 +86,7 @@ class SurePetcareLock(SurePetcareEntity, LockEntity):
async def async_unlock(self, **kwargs: Any) -> None: async def async_unlock(self, **kwargs: Any) -> None:
"""Unlock the lock.""" """Unlock the lock."""
if self.state != STATE_LOCKED: if self.state != LockState.LOCKED:
return return
self._attr_is_unlocking = True self._attr_is_unlocking = True
self.async_write_ha_state() self.async_write_ha_state()

16
homeassistant/components/template/lock.py
View File

@ -8,10 +8,8 @@ import voluptuous as vol
from homeassistant.components.lock import ( from homeassistant.components.lock import (
PLATFORM_SCHEMA as LOCK_PLATFORM_SCHEMA, PLATFORM_SCHEMA as LOCK_PLATFORM_SCHEMA,
STATE_JAMMED,
STATE_LOCKING,
STATE_UNLOCKING,
LockEntity, LockEntity,
LockState,
) )
from homeassistant.const import ( from homeassistant.const import (
ATTR_CODE, ATTR_CODE,
@ -19,9 +17,7 @@ from homeassistant.const import (
CONF_OPTIMISTIC, CONF_OPTIMISTIC,
CONF_UNIQUE_ID, CONF_UNIQUE_ID,
CONF_VALUE_TEMPLATE, CONF_VALUE_TEMPLATE,
STATE_LOCKED,
STATE_ON, STATE_ON,
STATE_UNLOCKED,
) )
from homeassistant.core import HomeAssistant, callback from homeassistant.core import HomeAssistant, callback
from homeassistant.exceptions import ServiceValidationError, TemplateError from homeassistant.exceptions import ServiceValidationError, TemplateError
@ -102,22 +98,22 @@ class TemplateLock(TemplateEntity, LockEntity):
@property @property
def is_locked(self) -> bool: def is_locked(self) -> bool:
"""Return true if lock is locked.""" """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 @property
def is_jammed(self) -> bool: def is_jammed(self) -> bool:
"""Return true if lock is jammed.""" """Return true if lock is jammed."""
return self._state == STATE_JAMMED return self._state == LockState.JAMMED
@property @property
def is_unlocking(self) -> bool: def is_unlocking(self) -> bool:
"""Return true if lock is unlocking.""" """Return true if lock is unlocking."""
return self._state == STATE_UNLOCKING return self._state == LockState.UNLOCKING
@property @property
def is_locking(self) -> bool: def is_locking(self) -> bool:
"""Return true if lock is locking.""" """Return true if lock is locking."""
return self._state == STATE_LOCKING return self._state == LockState.LOCKING
@callback @callback
def _update_state(self, result): def _update_state(self, result):
@ -128,7 +124,7 @@ class TemplateLock(TemplateEntity, LockEntity):
return return
if isinstance(result, bool): if isinstance(result, bool):
self._state = STATE_LOCKED if result else STATE_UNLOCKED self._state = LockState.LOCKED if result else LockState.UNLOCKED
return return
if isinstance(result, str): if isinstance(result, str):

14
homeassistant/components/verisure/lock.py
View File

@ -7,9 +7,9 @@ from typing import Any
from verisure import Error as VerisureError 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.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.core import HomeAssistant
from homeassistant.helpers.device_registry import DeviceInfo from homeassistant.helpers.device_registry import DeviceInfo
from homeassistant.helpers.entity_platform import ( from homeassistant.helpers.entity_platform import (
@ -130,19 +130,19 @@ class VerisureDoorlock(CoordinatorEntity[VerisureDataUpdateCoordinator], LockEnt
"""Send unlock command.""" """Send unlock command."""
code = kwargs.get(ATTR_CODE) code = kwargs.get(ATTR_CODE)
if 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: async def async_lock(self, **kwargs: Any) -> None:
"""Send lock command.""" """Send lock command."""
code = kwargs.get(ATTR_CODE) code = kwargs.get(ATTR_CODE)
if 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.""" """Send set lock state command."""
command = ( command = (
self.coordinator.verisure.door_lock(self.serial_number, code) 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) else self.coordinator.verisure.door_unlock(self.serial_number, code)
) )
lock_request = await self.hass.async_add_executor_job( lock_request = await self.hass.async_add_executor_job(
@ -151,7 +151,7 @@ class VerisureDoorlock(CoordinatorEntity[VerisureDataUpdateCoordinator], LockEnt
) )
LOGGER.debug("Verisure doorlock %s", state) LOGGER.debug("Verisure doorlock %s", state)
transaction_id = lock_request.get("data", {}).get(command["operationName"]) 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 lock_status = None
attempts = 0 attempts = 0
while lock_status != "OK": while lock_status != "OK":

9
homeassistant/components/xiaomi_aqara/lock.py
View File

@ -2,9 +2,8 @@
from __future__ import annotations 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.config_entries import ConfigEntry
from homeassistant.const import STATE_LOCKED, STATE_UNLOCKED
from homeassistant.core import HomeAssistant, callback from homeassistant.core import HomeAssistant, callback
from homeassistant.helpers.entity_platform import AddEntitiesCallback from homeassistant.helpers.entity_platform import AddEntitiesCallback
from homeassistant.helpers.event import async_call_later from homeassistant.helpers.event import async_call_later
@ -50,7 +49,7 @@ class XiaomiAqaraLock(LockEntity, XiaomiDevice):
def is_locked(self) -> bool | None: def is_locked(self) -> bool | None:
"""Return true if lock is locked.""" """Return true if lock is locked."""
if self._state is not None: if self._state is not None:
return self._state == STATE_LOCKED return self._state == LockState.LOCKED
return None return None
@property @property
@ -66,7 +65,7 @@ class XiaomiAqaraLock(LockEntity, XiaomiDevice):
@callback @callback
def clear_unlock_state(self, _): def clear_unlock_state(self, _):
"""Clear unlock state automatically.""" """Clear unlock state automatically."""
self._state = STATE_LOCKED self._state = LockState.LOCKED
self.async_write_ha_state() self.async_write_ha_state()
def parse_data(self, data, raw_data): def parse_data(self, data, raw_data):
@ -79,7 +78,7 @@ class XiaomiAqaraLock(LockEntity, XiaomiDevice):
if (value := data.get(key)) is not None: if (value := data.get(key)) is not None:
self._changed_by = int(value) self._changed_by = int(value)
self._verified_wrong_times = 0 self._verified_wrong_times = 0
self._state = STATE_UNLOCKED self._state = LockState.UNLOCKED
async_call_later( async_call_later(
self.hass, UNLOCK_MAINTAIN_TIME, self.clear_unlock_state self.hass, UNLOCK_MAINTAIN_TIME, self.clear_unlock_state
) )

17
homeassistant/components/yale_smart_alarm/lock.py
View File

@ -6,12 +6,7 @@ from typing import Any
from yalesmartalarmclient import YaleLock, YaleLockState from yalesmartalarmclient import YaleLock, YaleLockState
from homeassistant.components.lock import ( from homeassistant.components.lock import LockEntity, LockState
STATE_LOCKED,
STATE_OPEN,
STATE_UNLOCKED,
LockEntity,
)
from homeassistant.const import ATTR_CODE from homeassistant.const import ATTR_CODE
from homeassistant.core import HomeAssistant from homeassistant.core import HomeAssistant
from homeassistant.exceptions import HomeAssistantError, ServiceValidationError from homeassistant.exceptions import HomeAssistantError, ServiceValidationError
@ -28,9 +23,9 @@ from .coordinator import YaleDataUpdateCoordinator
from .entity import YaleLockEntity from .entity import YaleLockEntity
LOCK_STATE_MAP = { LOCK_STATE_MAP = {
YaleLockState.LOCKED: STATE_LOCKED, YaleLockState.LOCKED: LockState.LOCKED,
YaleLockState.UNLOCKED: STATE_UNLOCKED, YaleLockState.UNLOCKED: LockState.UNLOCKED,
YaleLockState.DOOR_OPEN: STATE_OPEN, YaleLockState.DOOR_OPEN: LockState.OPEN,
} }
@ -108,9 +103,9 @@ class YaleDoorlock(YaleLockEntity, LockEntity):
@property @property
def is_locked(self) -> bool | None: def is_locked(self) -> bool | None:
"""Return true if the lock is locked.""" """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 @property
def is_open(self) -> bool | None: def is_open(self) -> bool | None:
"""Return true if the lock is open.""" """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

17
homeassistant/components/zwave_js/lock.py
View File

@ -19,9 +19,8 @@ from zwave_js_server.const.command_class.lock import (
from zwave_js_server.exceptions import BaseZwaveJSServerError from zwave_js_server.exceptions import BaseZwaveJSServerError
from zwave_js_server.util.lock import clear_usercode, set_configuration, set_usercode 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.config_entries import ConfigEntry
from homeassistant.const import STATE_LOCKED, STATE_UNLOCKED
from homeassistant.core import HomeAssistant, callback from homeassistant.core import HomeAssistant, callback
from homeassistant.exceptions import HomeAssistantError from homeassistant.exceptions import HomeAssistantError
from homeassistant.helpers import config_validation as cv, entity_platform 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]] = { STATE_TO_ZWAVE_MAP: dict[int, dict[str, int | bool]] = {
CommandClass.DOOR_LOCK: { CommandClass.DOOR_LOCK: {
STATE_UNLOCKED: DoorLockMode.UNSECURED, LockState.UNLOCKED: DoorLockMode.UNSECURED,
STATE_LOCKED: DoorLockMode.SECURED, LockState.LOCKED: DoorLockMode.SECURED,
}, },
CommandClass.LOCK: { CommandClass.LOCK: {
STATE_UNLOCKED: False, LockState.UNLOCKED: False,
STATE_LOCKED: True, LockState.LOCKED: True,
}, },
} }
UNIT16_SCHEMA = vol.All(vol.Coerce(int), vol.Range(min=0, max=65535)) 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 == 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.""" """Set the lock state."""
target_value = self.get_zwave_value( target_value = self.get_zwave_value(
LOCK_CMD_CLASS_TO_PROPERTY_MAP[ LOCK_CMD_CLASS_TO_PROPERTY_MAP[
@ -155,11 +154,11 @@ class ZWaveLock(ZWaveBaseEntity, LockEntity):
async def async_lock(self, **kwargs: Any) -> None: async def async_lock(self, **kwargs: Any) -> None:
"""Lock the lock.""" """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: async def async_unlock(self, **kwargs: Any) -> None:
"""Unlock the lock.""" """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: async def async_set_lock_usercode(self, code_slot: int, usercode: str) -> None:
"""Set the usercode to index X on the lock.""" """Set the usercode to index X on the lock."""

34
homeassistant/const.py
View File

@ -487,15 +487,39 @@ STATE_ALARM_PENDING: Final = "pending"
STATE_ALARM_ARMING: Final = "arming" STATE_ALARM_ARMING: Final = "arming"
STATE_ALARM_DISARMING: Final = "disarming" STATE_ALARM_DISARMING: Final = "disarming"
STATE_ALARM_TRIGGERED: Final = "triggered" 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_UNAVAILABLE: Final = "unavailable"
STATE_OK: Final = "ok" STATE_OK: Final = "ok"
STATE_PROBLEM: Final = "problem" 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 #### # #### STATE AND EVENT ATTRIBUTES ####
# Attribution # Attribution
ATTR_ATTRIBUTION: Final = "attribution" ATTR_ATTRIBUTION: Final = "attribution"

7
homeassistant/helpers/state.py
View File

@ -9,17 +9,16 @@ import logging
from types import ModuleType from types import ModuleType
from typing import Any from typing import Any
from homeassistant.components.lock import LockState
from homeassistant.components.sun import STATE_ABOVE_HORIZON, STATE_BELOW_HORIZON from homeassistant.components.sun import STATE_ABOVE_HORIZON, STATE_BELOW_HORIZON
from homeassistant.const import ( from homeassistant.const import (
STATE_CLOSED, STATE_CLOSED,
STATE_HOME, STATE_HOME,
STATE_LOCKED,
STATE_NOT_HOME, STATE_NOT_HOME,
STATE_OFF, STATE_OFF,
STATE_ON, STATE_ON,
STATE_OPEN, STATE_OPEN,
STATE_UNKNOWN, STATE_UNKNOWN,
STATE_UNLOCKED,
) )
from homeassistant.core import Context, HomeAssistant, State from homeassistant.core import Context, HomeAssistant, State
from homeassistant.loader import IntegrationNotFound, async_get_integration, bind_hass 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 ( if state.state in (
STATE_ON, STATE_ON,
STATE_LOCKED, LockState.LOCKED,
STATE_ABOVE_HORIZON, STATE_ABOVE_HORIZON,
STATE_OPEN, STATE_OPEN,
STATE_HOME, STATE_HOME,
@ -87,7 +86,7 @@ def state_as_number(state: State) -> float:
return 1 return 1
if state.state in ( if state.state in (
STATE_OFF, STATE_OFF,
STATE_UNLOCKED, LockState.UNLOCKED,
STATE_UNKNOWN, STATE_UNKNOWN,
STATE_BELOW_HORIZON, STATE_BELOW_HORIZON,
STATE_CLOSED, STATE_CLOSED,

5
tests/components/abode/test_lock.py
View File

@ -3,13 +3,12 @@
from unittest.mock import patch from unittest.mock import patch
from homeassistant.components.abode import ATTR_DEVICE_ID 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 ( from homeassistant.const import (
ATTR_ENTITY_ID, ATTR_ENTITY_ID,
ATTR_FRIENDLY_NAME, ATTR_FRIENDLY_NAME,
SERVICE_LOCK, SERVICE_LOCK,
SERVICE_UNLOCK, SERVICE_UNLOCK,
STATE_LOCKED,
) )
from homeassistant.core import HomeAssistant from homeassistant.core import HomeAssistant
from homeassistant.helpers import entity_registry as er 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) await setup_platform(hass, LOCK_DOMAIN)
state = hass.states.get(DEVICE_ID) 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 state.attributes.get(ATTR_DEVICE_ID) == "ZW:00000004"
assert not state.attributes.get("battery_low") assert not state.attributes.get("battery_low")
assert not state.attributes.get("no_response") assert not state.attributes.get("no_response")

14
tests/components/alexa/test_capabilities.py
View File

@ -11,7 +11,7 @@ from homeassistant.components.climate import (
ClimateEntityFeature, ClimateEntityFeature,
HVACMode, 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.media_player import MediaPlayerEntityFeature
from homeassistant.components.valve import ValveEntityFeature from homeassistant.components.valve import ValveEntityFeature
from homeassistant.components.water_heater import ( from homeassistant.components.water_heater import (
@ -28,11 +28,9 @@ from homeassistant.const import (
STATE_ALARM_ARMED_HOME, STATE_ALARM_ARMED_HOME,
STATE_ALARM_ARMED_NIGHT, STATE_ALARM_ARMED_NIGHT,
STATE_ALARM_DISARMED, STATE_ALARM_DISARMED,
STATE_LOCKED,
STATE_OFF, STATE_OFF,
STATE_UNAVAILABLE, STATE_UNAVAILABLE,
STATE_UNKNOWN, STATE_UNKNOWN,
STATE_UNLOCKED,
UnitOfTemperature, UnitOfTemperature,
) )
from homeassistant.core import HomeAssistant 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: async def test_report_lock_state(hass: HomeAssistant) -> None:
"""Test LockController implements lockState property.""" """Test LockController implements lockState property."""
hass.states.async_set("lock.locked", STATE_LOCKED, {}) hass.states.async_set("lock.locked", LockState.LOCKED, {})
hass.states.async_set("lock.unlocked", STATE_UNLOCKED, {}) hass.states.async_set("lock.unlocked", LockState.UNLOCKED, {})
hass.states.async_set("lock.unlocking", STATE_UNLOCKING, {}) hass.states.async_set("lock.unlocking", LockState.UNLOCKING, {})
hass.states.async_set("lock.locking", STATE_LOCKING, {}) hass.states.async_set("lock.locking", LockState.LOCKING, {})
hass.states.async_set("lock.jammed", STATE_JAMMED, {}) hass.states.async_set("lock.jammed", LockState.JAMMED, {})
hass.states.async_set("lock.unknown", STATE_UNKNOWN, {}) hass.states.async_set("lock.unknown", STATE_UNKNOWN, {})
properties = await reported_properties(hass, "lock.locked") properties = await reported_properties(hass, "lock.locked")

5
tests/components/august/test_init.py
View File

@ -9,14 +9,13 @@ from yalexs.const import Brand
from yalexs.exceptions import AugustApiAIOHTTPError from yalexs.exceptions import AugustApiAIOHTTPError
from homeassistant.components.august.const import DOMAIN 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.config_entries import ConfigEntryState
from homeassistant.const import ( from homeassistant.const import (
ATTR_ENTITY_ID, ATTR_ENTITY_ID,
SERVICE_LOCK, SERVICE_LOCK,
SERVICE_OPEN, SERVICE_OPEN,
SERVICE_UNLOCK, SERVICE_UNLOCK,
STATE_LOCKED,
STATE_ON, STATE_ON,
) )
from homeassistant.core import HomeAssistant 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 = hass.states.get(
"lock.a6697750d607098bae8d6baa11ef8063_name" "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: async def test_lock_has_doorsense(hass: HomeAssistant) -> None:

65
tests/components/august/test_lock.py
View File

@ -10,21 +10,14 @@ from syrupy import SnapshotAssertion
from yalexs.manager.activity import INITIAL_LOCK_RESYNC_TIME from yalexs.manager.activity import INITIAL_LOCK_RESYNC_TIME
from yalexs.pubnub_async import AugustPubNub from yalexs.pubnub_async import AugustPubNub
from homeassistant.components.lock import ( from homeassistant.components.lock import DOMAIN as LOCK_DOMAIN, LockState
DOMAIN as LOCK_DOMAIN,
STATE_JAMMED,
STATE_LOCKING,
STATE_UNLOCKING,
)
from homeassistant.const import ( from homeassistant.const import (
ATTR_ENTITY_ID, ATTR_ENTITY_ID,
SERVICE_LOCK, SERVICE_LOCK,
SERVICE_OPEN, SERVICE_OPEN,
SERVICE_UNLOCK, SERVICE_UNLOCK,
STATE_LOCKED,
STATE_UNAVAILABLE, STATE_UNAVAILABLE,
STATE_UNKNOWN, STATE_UNKNOWN,
STATE_UNLOCKED,
) )
from homeassistant.core import HomeAssistant from homeassistant.core import HomeAssistant
from homeassistant.exceptions import HomeAssistantError 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") 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" 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") activities = await _mock_activities_from_fixture(hass, "get_activity.locking.json")
await _create_august_with_devices(hass, [lock_one], activities=activities) 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: 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) 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: 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") activities = await _mock_activities_from_fixture(hass, "get_activity.jammed.json")
await _create_august_with_devices(hass, [lock_one], activities=activities) 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( 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") 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["battery_level"] == 92
assert lock_state.attributes["friendly_name"] == "online_with_doorsense Name" 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) await hass.services.async_call(LOCK_DOMAIN, SERVICE_UNLOCK, data, blocking=True)
lock_state = states.get("lock.online_with_doorsense_name") 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["battery_level"] == 92
assert lock_state.attributes["friendly_name"] == "online_with_doorsense Name" assert lock_state.attributes["friendly_name"] == "online_with_doorsense Name"
await hass.services.async_call(LOCK_DOMAIN, SERVICE_LOCK, data, blocking=True) 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 # No activity means it will be unavailable until the activity feed has data
lock_operator_sensor = entity_registry.async_get( 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]) await _create_august_with_devices(hass, [lock_with_unlatch])
lock_online_with_unlatch_name = hass.states.get("lock.online_with_unlatch_name") 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"} data = {ATTR_ENTITY_ID: "lock.online_with_unlatch_name"}
await hass.services.async_call(LOCK_DOMAIN, SERVICE_OPEN, data, blocking=True) 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") 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( 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) await _create_august_with_devices(hass, [lock_with_unlatch], pubnub=pubnub)
pubnub.connected = True 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"} data = {ATTR_ENTITY_ID: "lock.online_with_unlatch_name"}
await hass.services.async_call(LOCK_DOMAIN, SERVICE_OPEN, data, blocking=True) 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()
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() 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") 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["battery_level"] == 92
assert lock_state.attributes["friendly_name"] == "online_with_doorsense Name" 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() await hass.async_block_till_done()
lock_state = hass.states.get("lock.online_with_doorsense_name") 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["battery_level"] == 92
assert lock_state.attributes["friendly_name"] == "online_with_doorsense Name" 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() await hass.async_block_till_done()
lock_state = hass.states.get("lock.online_with_doorsense_name") 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 # No activity means it will be unavailable until the activity feed has data
lock_operator_sensor = entity_registry.async_get( 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() await hass.async_block_till_done()
lock_state = hass.states.get("lock.online_with_doorsense_name") 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: 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") 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["battery_level"] == 92
assert lock_state.attributes["friendly_name"] == "online_with_doorsense Name" 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) await hass.services.async_call(LOCK_DOMAIN, SERVICE_UNLOCK, data, blocking=True)
lock_state = hass.states.get("lock.online_with_doorsense_name") 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( 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") 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["battery_level"] == 92
assert lock_state.attributes["friendly_name"] == "online_with_doorsense Name" 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) 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: 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 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.message(
pubnub, 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()
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.message(
pubnub, 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()
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)) async_fire_time_changed(hass, dt_util.utcnow() + datetime.timedelta(seconds=30))
await hass.async_block_till_done() 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 pubnub.connected = True
async_fire_time_changed(hass, dt_util.utcnow() + datetime.timedelta(seconds=30)) async_fire_time_changed(hass, dt_util.utcnow() + datetime.timedelta(seconds=30))
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
# Ensure pubnub status is always preserved # Ensure pubnub status is always preserved
async_fire_time_changed(hass, dt_util.utcnow() + datetime.timedelta(hours=2)) async_fire_time_changed(hass, dt_util.utcnow() + datetime.timedelta(hours=2))
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
pubnub.message( pubnub.message(
pubnub, 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()
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)) async_fire_time_changed(hass, dt_util.utcnow() + datetime.timedelta(hours=4))
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
await hass.config_entries.async_unload(config_entry.entry_id) await hass.config_entries.async_unload(config_entry.entry_id)
await hass.async_block_till_done() await hass.async_block_till_done()

11
tests/components/deconz/test_lock.py
View File

@ -8,8 +8,9 @@ from homeassistant.components.lock import (
DOMAIN as LOCK_DOMAIN, DOMAIN as LOCK_DOMAIN,
SERVICE_LOCK, SERVICE_LOCK,
SERVICE_UNLOCK, 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.core import HomeAssistant
from .conftest import WebsocketDataType from .conftest import WebsocketDataType
@ -43,10 +44,10 @@ async def test_lock_from_light(
) -> None: ) -> None:
"""Test that all supported lock entities based on lights are created.""" """Test that all supported lock entities based on lights are created."""
assert len(hass.states.async_all()) == 1 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}}) 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 # Verify service calls
@ -107,10 +108,10 @@ async def test_lock_from_sensor(
) -> None: ) -> None:
"""Test that all supported lock entities based on sensors are created.""" """Test that all supported lock entities based on sensors are created."""
assert len(hass.states.async_all()) == 2 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"}}) 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 # Verify service calls

38
tests/components/demo/test_lock.py
View File

@ -10,19 +10,9 @@ from homeassistant.components.lock import (
SERVICE_LOCK, SERVICE_LOCK,
SERVICE_OPEN, SERVICE_OPEN,
SERVICE_UNLOCK, SERVICE_UNLOCK,
STATE_JAMMED, LockState,
STATE_LOCKED,
STATE_LOCKING,
STATE_UNLOCKED,
STATE_UNLOCKING,
)
from homeassistant.const import (
ATTR_ENTITY_ID,
EVENT_STATE_CHANGED,
STATE_OPEN,
STATE_OPENING,
Platform,
) )
from homeassistant.const import ATTR_ENTITY_ID, EVENT_STATE_CHANGED, Platform
from homeassistant.core import HomeAssistant from homeassistant.core import HomeAssistant
from homeassistant.setup import async_setup_component 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: async def test_locking(hass: HomeAssistant) -> None:
"""Test the locking of a lock.""" """Test the locking of a lock."""
state = hass.states.get(KITCHEN) state = hass.states.get(KITCHEN)
assert state.state == STATE_UNLOCKED assert state.state == LockState.UNLOCKED
await hass.async_block_till_done() await hass.async_block_till_done()
state_changes = async_capture_events(hass, EVENT_STATE_CHANGED) 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() await hass.async_block_till_done()
assert state_changes[0].data["entity_id"] == KITCHEN 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["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) @patch.object(demo_lock, "LOCK_UNLOCK_DELAY", 0)
async def test_unlocking(hass: HomeAssistant) -> None: async def test_unlocking(hass: HomeAssistant) -> None:
"""Test the unlocking of a lock.""" """Test the unlocking of a lock."""
state = hass.states.get(FRONT) state = hass.states.get(FRONT)
assert state.state == STATE_LOCKED assert state.state == LockState.LOCKED
await hass.async_block_till_done() await hass.async_block_till_done()
state_changes = async_capture_events(hass, EVENT_STATE_CHANGED) 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() await hass.async_block_till_done()
assert state_changes[0].data["entity_id"] == FRONT 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["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) @patch.object(demo_lock, "LOCK_UNLOCK_DELAY", 0)
async def test_opening(hass: HomeAssistant) -> None: async def test_opening(hass: HomeAssistant) -> None:
"""Test the opening of a lock.""" """Test the opening of a lock."""
state = hass.states.get(OPENABLE_LOCK) state = hass.states.get(OPENABLE_LOCK)
assert state.state == STATE_LOCKED assert state.state == LockState.LOCKED
await hass.async_block_till_done() await hass.async_block_till_done()
state_changes = async_capture_events(hass, EVENT_STATE_CHANGED) 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() await hass.async_block_till_done()
assert state_changes[0].data["entity_id"] == OPENABLE_LOCK 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["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) @patch.object(demo_lock, "LOCK_UNLOCK_DELAY", 0)
async def test_jammed_when_locking(hass: HomeAssistant) -> None: async def test_jammed_when_locking(hass: HomeAssistant) -> None:
"""Test the locking of a lock jams.""" """Test the locking of a lock jams."""
state = hass.states.get(POORLY_INSTALLED) state = hass.states.get(POORLY_INSTALLED)
assert state.state == STATE_UNLOCKED assert state.state == LockState.UNLOCKED
await hass.async_block_till_done() await hass.async_block_till_done()
state_changes = async_capture_events(hass, EVENT_STATE_CHANGED) 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() await hass.async_block_till_done()
assert state_changes[0].data["entity_id"] == POORLY_INSTALLED 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["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: async def test_opening_mocked(hass: HomeAssistant) -> None:

24
tests/components/esphome/test_lock.py
View File

@ -2,16 +2,20 @@
from unittest.mock import call 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 ( from homeassistant.components.lock import (
DOMAIN as LOCK_DOMAIN, DOMAIN as LOCK_DOMAIN,
SERVICE_LOCK, SERVICE_LOCK,
SERVICE_OPEN, SERVICE_OPEN,
SERVICE_UNLOCK, SERVICE_UNLOCK,
STATE_LOCKED, LockState,
STATE_LOCKING,
STATE_UNLOCKING,
) )
from homeassistant.const import ATTR_ENTITY_ID from homeassistant.const import ATTR_ENTITY_ID
from homeassistant.core import HomeAssistant from homeassistant.core import HomeAssistant
@ -31,7 +35,7 @@ async def test_lock_entity_no_open(
requires_code=False, requires_code=False,
) )
] ]
states = [LockEntityState(key=1, state=LockState.UNLOCKING)] states = [LockEntityState(key=1, state=ESPHomeLockState.UNLOCKING)]
user_service = [] user_service = []
await mock_generic_device_entry( await mock_generic_device_entry(
mock_client=mock_client, mock_client=mock_client,
@ -41,7 +45,7 @@ async def test_lock_entity_no_open(
) )
state = hass.states.get("lock.test_mylock") state = hass.states.get("lock.test_mylock")
assert state is not None assert state is not None
assert state.state == STATE_UNLOCKING assert state.state == LockState.UNLOCKING
await hass.services.async_call( await hass.services.async_call(
LOCK_DOMAIN, LOCK_DOMAIN,
@ -65,7 +69,7 @@ async def test_lock_entity_start_locked(
unique_id="my_lock", unique_id="my_lock",
) )
] ]
states = [LockEntityState(key=1, state=LockState.LOCKED)] states = [LockEntityState(key=1, state=ESPHomeLockState.LOCKED)]
user_service = [] user_service = []
await mock_generic_device_entry( await mock_generic_device_entry(
mock_client=mock_client, mock_client=mock_client,
@ -75,7 +79,7 @@ async def test_lock_entity_start_locked(
) )
state = hass.states.get("lock.test_mylock") state = hass.states.get("lock.test_mylock")
assert state is not None assert state is not None
assert state.state == STATE_LOCKED assert state.state == LockState.LOCKED
async def test_lock_entity_supports_open( async def test_lock_entity_supports_open(
@ -92,7 +96,7 @@ async def test_lock_entity_supports_open(
requires_code=True, requires_code=True,
) )
] ]
states = [LockEntityState(key=1, state=LockState.LOCKING)] states = [LockEntityState(key=1, state=ESPHomeLockState.LOCKING)]
user_service = [] user_service = []
await mock_generic_device_entry( await mock_generic_device_entry(
mock_client=mock_client, mock_client=mock_client,
@ -102,7 +106,7 @@ async def test_lock_entity_supports_open(
) )
state = hass.states.get("lock.test_mylock") state = hass.states.get("lock.test_mylock")
assert state is not None assert state is not None
assert state.state == STATE_LOCKING assert state.state == LockState.LOCKING
await hass.services.async_call( await hass.services.async_call(
LOCK_DOMAIN, LOCK_DOMAIN,

15
tests/components/freedompro/test_lock.py
View File

@ -7,8 +7,9 @@ from homeassistant.components.lock import (
DOMAIN as LOCK_DOMAIN, DOMAIN as LOCK_DOMAIN,
SERVICE_LOCK, SERVICE_LOCK,
SERVICE_UNLOCK, 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.core import HomeAssistant
from homeassistant.helpers import device_registry as dr, entity_registry as er from homeassistant.helpers import device_registry as dr, entity_registry as er
from homeassistant.helpers.entity_component import async_update_entity from homeassistant.helpers.entity_component import async_update_entity
@ -39,7 +40,7 @@ async def test_lock_get_state(
entity_id = "lock.lock" entity_id = "lock.lock"
state = hass.states.get(entity_id) state = hass.states.get(entity_id)
assert state assert state
assert state.state == STATE_UNLOCKED assert state.state == LockState.UNLOCKED
assert state.attributes.get("friendly_name") == "lock" assert state.attributes.get("friendly_name") == "lock"
entry = entity_registry.async_get(entity_id) entry = entity_registry.async_get(entity_id)
@ -63,7 +64,7 @@ async def test_lock_get_state(
assert entry assert entry
assert entry.unique_id == uid assert entry.unique_id == uid
assert state.state == STATE_LOCKED assert state.state == LockState.LOCKED
async def test_lock_set_unlock( async def test_lock_set_unlock(
@ -87,7 +88,7 @@ async def test_lock_set_unlock(
state = hass.states.get(entity_id) state = hass.states.get(entity_id)
assert state assert state
assert state.state == STATE_LOCKED assert state.state == LockState.LOCKED
assert state.attributes.get("friendly_name") == "lock" assert state.attributes.get("friendly_name") == "lock"
entry = entity_registry.async_get(entity_id) entry = entity_registry.async_get(entity_id)
@ -113,7 +114,7 @@ async def test_lock_set_unlock(
await hass.async_block_till_done() await hass.async_block_till_done()
state = hass.states.get(entity_id) state = hass.states.get(entity_id)
assert state.state == STATE_UNLOCKED assert state.state == LockState.UNLOCKED
async def test_lock_set_lock( async def test_lock_set_lock(
@ -126,7 +127,7 @@ async def test_lock_set_lock(
entity_id = "lock.lock" entity_id = "lock.lock"
state = hass.states.get(entity_id) state = hass.states.get(entity_id)
assert state assert state
assert state.state == STATE_UNLOCKED assert state.state == LockState.UNLOCKED
assert state.attributes.get("friendly_name") == "lock" assert state.attributes.get("friendly_name") == "lock"
entry = entity_registry.async_get(entity_id) entry = entity_registry.async_get(entity_id)
@ -153,4 +154,4 @@ async def test_lock_set_lock(
await hass.async_block_till_done() await hass.async_block_till_done()
state = hass.states.get(entity_id) state = hass.states.get(entity_id)
assert state.state == STATE_LOCKED assert state.state == LockState.LOCKED

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

@ -1602,7 +1602,7 @@ async def test_lock_unlock_lock(hass: HomeAssistant) -> None:
assert trait.LockUnlockTrait.might_2fa(lock.DOMAIN, LockEntityFeature.OPEN, None) assert trait.LockUnlockTrait.might_2fa(lock.DOMAIN, LockEntityFeature.OPEN, None)
trt = trait.LockUnlockTrait( 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() == {} 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) assert trait.LockUnlockTrait.might_2fa(lock.DOMAIN, LockEntityFeature.OPEN, None)
trt = trait.LockUnlockTrait( 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() == {} 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) assert trait.LockUnlockTrait.might_2fa(lock.DOMAIN, LockEntityFeature.OPEN, None)
trt = trait.LockUnlockTrait( 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() == {} assert trt.sync_attributes() == {}
@ -1670,7 +1670,7 @@ async def test_lock_unlock_unlock(hass: HomeAssistant) -> None:
) )
trt = trait.LockUnlockTrait( 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() == {} assert trt.sync_attributes() == {}
@ -1706,7 +1706,7 @@ async def test_lock_unlock_unlock(hass: HomeAssistant) -> None:
# Test without pin # Test without pin
trt = trait.LockUnlockTrait( 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: with pytest.raises(error.SmartHomeError) as err:

76
tests/components/group/test_init.py
View File

@ -11,6 +11,7 @@ import pytest
from homeassistant.components import group from homeassistant.components import group
from homeassistant.components.group.registry import GroupIntegrationRegistry from homeassistant.components.group.registry import GroupIntegrationRegistry
from homeassistant.components.lock import LockState
from homeassistant.const import ( from homeassistant.const import (
ATTR_ASSUMED_STATE, ATTR_ASSUMED_STATE,
ATTR_FRIENDLY_NAME, ATTR_FRIENDLY_NAME,
@ -19,17 +20,10 @@ from homeassistant.const import (
SERVICE_RELOAD, SERVICE_RELOAD,
STATE_CLOSED, STATE_CLOSED,
STATE_HOME, STATE_HOME,
STATE_JAMMED,
STATE_LOCKED,
STATE_LOCKING,
STATE_NOT_HOME, STATE_NOT_HOME,
STATE_OFF, STATE_OFF,
STATE_ON, STATE_ON,
STATE_OPEN,
STATE_OPENING,
STATE_UNKNOWN, STATE_UNKNOWN,
STATE_UNLOCKED,
STATE_UNLOCKING,
) )
from homeassistant.core import CoreState, HomeAssistant from homeassistant.core import CoreState, HomeAssistant
from homeassistant.helpers import entity_registry as er from homeassistant.helpers import entity_registry as er
@ -740,78 +734,78 @@ async def test_is_on(hass: HomeAssistant) -> None:
), ),
( (
("cover", "cover"), ("cover", "cover"),
(STATE_OPEN, STATE_CLOSED), (LockState.OPEN, STATE_CLOSED),
(STATE_CLOSED, STATE_CLOSED), (STATE_CLOSED, STATE_CLOSED),
(STATE_OPEN, True), (LockState.OPEN, True),
(STATE_CLOSED, False), (STATE_CLOSED, False),
), ),
( (
("lock", "lock"), ("lock", "lock"),
(STATE_UNLOCKED, STATE_LOCKED), (LockState.UNLOCKED, LockState.LOCKED),
(STATE_LOCKED, STATE_LOCKED), (LockState.LOCKED, LockState.LOCKED),
(STATE_UNLOCKED, True), (LockState.UNLOCKED, True),
(STATE_LOCKED, False), (LockState.LOCKED, False),
), ),
( (
("cover", "lock"), ("cover", "lock"),
(STATE_OPEN, STATE_LOCKED), (LockState.OPEN, LockState.LOCKED),
(STATE_CLOSED, STATE_LOCKED), (STATE_CLOSED, LockState.LOCKED),
(STATE_ON, True), (STATE_ON, True),
(STATE_OFF, False), (STATE_OFF, False),
), ),
( (
("cover", "lock"), ("cover", "lock"),
(STATE_OPEN, STATE_UNLOCKED), (LockState.OPEN, LockState.UNLOCKED),
(STATE_CLOSED, STATE_LOCKED), (STATE_CLOSED, LockState.LOCKED),
(STATE_ON, True), (STATE_ON, True),
(STATE_OFF, False), (STATE_OFF, False),
), ),
( (
("cover", "lock", "light"), ("cover", "lock", "light"),
(STATE_OPEN, STATE_LOCKED, STATE_ON), (LockState.OPEN, LockState.LOCKED, STATE_ON),
(STATE_CLOSED, STATE_LOCKED, STATE_OFF), (STATE_CLOSED, LockState.LOCKED, STATE_OFF),
(STATE_ON, True), (STATE_ON, True),
(STATE_OFF, False), (STATE_OFF, False),
), ),
( (
("lock", "lock"), ("lock", "lock"),
(STATE_OPEN, STATE_LOCKED), (LockState.OPEN, LockState.LOCKED),
(STATE_LOCKED, STATE_LOCKED), (LockState.LOCKED, LockState.LOCKED),
(STATE_UNLOCKED, True), (LockState.UNLOCKED, True),
(STATE_LOCKED, False), (LockState.LOCKED, False),
), ),
( (
("lock", "lock"), ("lock", "lock"),
(STATE_OPENING, STATE_LOCKED), (LockState.OPENING, LockState.LOCKED),
(STATE_LOCKED, STATE_LOCKED), (LockState.LOCKED, LockState.LOCKED),
(STATE_UNLOCKED, True), (LockState.UNLOCKED, True),
(STATE_LOCKED, False), (LockState.LOCKED, False),
), ),
( (
("lock", "lock"), ("lock", "lock"),
(STATE_UNLOCKING, STATE_LOCKED), (LockState.UNLOCKING, LockState.LOCKED),
(STATE_LOCKED, STATE_LOCKED), (LockState.LOCKED, LockState.LOCKED),
(STATE_UNLOCKED, True), (LockState.UNLOCKED, True),
(STATE_LOCKED, False), (LockState.LOCKED, False),
), ),
( (
("lock", "lock"), ("lock", "lock"),
(STATE_LOCKING, STATE_LOCKED), (LockState.LOCKING, LockState.LOCKED),
(STATE_LOCKED, STATE_LOCKED), (LockState.LOCKED, LockState.LOCKED),
(STATE_UNLOCKED, True), (LockState.UNLOCKED, True),
(STATE_LOCKED, False), (LockState.LOCKED, False),
), ),
( (
("lock", "lock"), ("lock", "lock"),
(STATE_JAMMED, STATE_LOCKED), (LockState.JAMMED, LockState.LOCKED),
(STATE_LOCKED, STATE_LOCKED), (LockState.LOCKED, LockState.LOCKED),
(STATE_LOCKED, False), (LockState.LOCKED, False),
(STATE_LOCKED, False), (LockState.LOCKED, False),
), ),
( (
("cover", "lock"), ("cover", "lock"),
(STATE_OPEN, STATE_OPEN), (LockState.OPEN, LockState.OPEN),
(STATE_CLOSED, STATE_LOCKED), (STATE_CLOSED, LockState.LOCKED),
(STATE_ON, True), (STATE_ON, True),
(STATE_OFF, False), (STATE_OFF, False),
), ),

125
tests/components/group/test_lock.py
View File

@ -12,18 +12,9 @@ from homeassistant.components.lock import (
SERVICE_LOCK, SERVICE_LOCK,
SERVICE_OPEN, SERVICE_OPEN,
SERVICE_UNLOCK, SERVICE_UNLOCK,
LockState,
) )
from homeassistant.const import ( from homeassistant.const import ATTR_ENTITY_ID, STATE_UNAVAILABLE, STATE_UNKNOWN
ATTR_ENTITY_ID,
STATE_JAMMED,
STATE_LOCKED,
STATE_LOCKING,
STATE_OPEN,
STATE_UNAVAILABLE,
STATE_UNKNOWN,
STATE_UNLOCKED,
STATE_UNLOCKING,
)
from homeassistant.core import HomeAssistant from homeassistant.core import HomeAssistant
from homeassistant.exceptions import HomeAssistantError from homeassistant.exceptions import HomeAssistantError
from homeassistant.helpers import entity_registry as er from homeassistant.helpers import entity_registry as er
@ -55,7 +46,7 @@ async def test_default_state(
state = hass.states.get("lock.door_group") state = hass.states.get("lock.door_group")
assert state is not None 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"] assert state.attributes.get(ATTR_ENTITY_ID) == ["lock.front", "lock.back"]
entry = entity_registry.async_get("lock.door_group") 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 # At least one member jammed -> group jammed
for state_1 in ( for state_1 in (
STATE_JAMMED, LockState.JAMMED,
STATE_LOCKED, LockState.LOCKED,
STATE_LOCKING, LockState.LOCKING,
STATE_UNAVAILABLE, STATE_UNAVAILABLE,
STATE_UNKNOWN, STATE_UNKNOWN,
STATE_UNLOCKED, LockState.UNLOCKED,
STATE_UNLOCKING, LockState.UNLOCKING,
): ):
hass.states.async_set("lock.test1", state_1) 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() 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 # At least one member locking -> group unlocking
for state_1 in ( for state_1 in (
STATE_LOCKED, LockState.LOCKED,
STATE_LOCKING, LockState.LOCKING,
STATE_UNAVAILABLE, STATE_UNAVAILABLE,
STATE_UNKNOWN, STATE_UNKNOWN,
STATE_UNLOCKED, LockState.UNLOCKED,
STATE_UNLOCKING, LockState.UNLOCKING,
): ):
hass.states.async_set("lock.test1", state_1) 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() 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 # At least one member unlocking -> group unlocking
for state_1 in ( for state_1 in (
STATE_LOCKED, LockState.LOCKED,
STATE_UNAVAILABLE, STATE_UNAVAILABLE,
STATE_UNKNOWN, STATE_UNKNOWN,
STATE_UNLOCKED, LockState.UNLOCKED,
STATE_UNLOCKING, LockState.UNLOCKING,
): ):
hass.states.async_set("lock.test1", state_1) 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() 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 # At least one member unlocked -> group unlocked
for state_1 in ( for state_1 in (
STATE_LOCKED, LockState.LOCKED,
STATE_UNAVAILABLE, STATE_UNAVAILABLE,
STATE_UNKNOWN, STATE_UNKNOWN,
STATE_UNLOCKED, LockState.UNLOCKED,
): ):
hass.states.async_set("lock.test1", state_1) 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() 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 # Otherwise -> locked
hass.states.async_set("lock.test1", STATE_LOCKED) hass.states.async_set("lock.test1", LockState.LOCKED)
hass.states.async_set("lock.test2", STATE_LOCKED) hass.states.async_set("lock.test2", LockState.LOCKED)
await hass.async_block_till_done() 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 # All group members removed from the state machine -> unavailable
hass.states.async_remove("lock.test1") 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() await hass.async_block_till_done()
group_state = hass.states.get("lock.lock_group") group_state = hass.states.get("lock.lock_group")
assert group_state.state == STATE_UNLOCKED assert group_state.state == LockState.UNLOCKED
assert hass.states.get("lock.openable_lock").state == STATE_LOCKED assert hass.states.get("lock.openable_lock").state == LockState.LOCKED
assert hass.states.get("lock.another_openable_lock").state == STATE_UNLOCKED assert hass.states.get("lock.another_openable_lock").state == LockState.UNLOCKED
await hass.services.async_call( await hass.services.async_call(
LOCK_DOMAIN, LOCK_DOMAIN,
@ -205,8 +196,8 @@ async def test_service_calls_openable(hass: HomeAssistant) -> None:
{ATTR_ENTITY_ID: "lock.lock_group"}, {ATTR_ENTITY_ID: "lock.lock_group"},
blocking=True, blocking=True,
) )
assert hass.states.get("lock.openable_lock").state == STATE_OPEN assert hass.states.get("lock.openable_lock").state == LockState.OPEN
assert hass.states.get("lock.another_openable_lock").state == STATE_OPEN assert hass.states.get("lock.another_openable_lock").state == LockState.OPEN
await hass.services.async_call( await hass.services.async_call(
LOCK_DOMAIN, LOCK_DOMAIN,
@ -214,8 +205,8 @@ async def test_service_calls_openable(hass: HomeAssistant) -> None:
{ATTR_ENTITY_ID: "lock.lock_group"}, {ATTR_ENTITY_ID: "lock.lock_group"},
blocking=True, blocking=True,
) )
assert hass.states.get("lock.openable_lock").state == STATE_LOCKED assert hass.states.get("lock.openable_lock").state == LockState.LOCKED
assert hass.states.get("lock.another_openable_lock").state == STATE_LOCKED assert hass.states.get("lock.another_openable_lock").state == LockState.LOCKED
await hass.services.async_call( await hass.services.async_call(
LOCK_DOMAIN, LOCK_DOMAIN,
@ -223,8 +214,8 @@ async def test_service_calls_openable(hass: HomeAssistant) -> None:
{ATTR_ENTITY_ID: "lock.lock_group"}, {ATTR_ENTITY_ID: "lock.lock_group"},
blocking=True, blocking=True,
) )
assert hass.states.get("lock.openable_lock").state == STATE_UNLOCKED assert hass.states.get("lock.openable_lock").state == LockState.UNLOCKED
assert hass.states.get("lock.another_openable_lock").state == STATE_UNLOCKED assert hass.states.get("lock.another_openable_lock").state == LockState.UNLOCKED
async def test_service_calls_basic(hass: HomeAssistant) -> None: 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() await hass.async_block_till_done()
group_state = hass.states.get("lock.lock_group") group_state = hass.states.get("lock.lock_group")
assert group_state.state == STATE_UNLOCKED assert group_state.state == LockState.UNLOCKED
assert hass.states.get("lock.basic_lock").state == STATE_LOCKED assert hass.states.get("lock.basic_lock").state == LockState.LOCKED
assert hass.states.get("lock.another_basic_lock").state == STATE_UNLOCKED assert hass.states.get("lock.another_basic_lock").state == LockState.UNLOCKED
await hass.services.async_call( await hass.services.async_call(
LOCK_DOMAIN, LOCK_DOMAIN,
@ -258,8 +249,8 @@ async def test_service_calls_basic(hass: HomeAssistant) -> None:
{ATTR_ENTITY_ID: "lock.lock_group"}, {ATTR_ENTITY_ID: "lock.lock_group"},
blocking=True, blocking=True,
) )
assert hass.states.get("lock.basic_lock").state == STATE_LOCKED assert hass.states.get("lock.basic_lock").state == LockState.LOCKED
assert hass.states.get("lock.another_basic_lock").state == STATE_LOCKED assert hass.states.get("lock.another_basic_lock").state == LockState.LOCKED
await hass.services.async_call( await hass.services.async_call(
LOCK_DOMAIN, LOCK_DOMAIN,
@ -267,8 +258,8 @@ async def test_service_calls_basic(hass: HomeAssistant) -> None:
{ATTR_ENTITY_ID: "lock.lock_group"}, {ATTR_ENTITY_ID: "lock.lock_group"},
blocking=True, blocking=True,
) )
assert hass.states.get("lock.basic_lock").state == STATE_UNLOCKED assert hass.states.get("lock.basic_lock").state == LockState.UNLOCKED
assert hass.states.get("lock.another_basic_lock").state == STATE_UNLOCKED assert hass.states.get("lock.another_basic_lock").state == LockState.UNLOCKED
with pytest.raises(HomeAssistantError): with pytest.raises(HomeAssistantError):
await hass.services.async_call( await hass.services.async_call(
@ -303,7 +294,7 @@ async def test_reload(hass: HomeAssistant) -> None:
await hass.async_start() await hass.async_start()
await hass.async_block_till_done() 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") yaml_path = get_fixture_path("configuration.yaml", "group")
with patch.object(hass_config, "YAML_CONFIG_FILE", yaml_path): 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: async def test_reload_with_platform_not_setup(hass: HomeAssistant) -> None:
"""Test the ability to reload locks.""" """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( await async_setup_component(
hass, hass,
LOCK_DOMAIN, LOCK_DOMAIN,
@ -372,11 +363,11 @@ async def test_reload_with_base_integration_platform_not_setup(
}, },
) )
await hass.async_block_till_done() await hass.async_block_till_done()
hass.states.async_set("lock.front_lock", STATE_LOCKED) hass.states.async_set("lock.front_lock", LockState.LOCKED)
hass.states.async_set("lock.back_lock", STATE_UNLOCKED) 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", LockState.LOCKED)
hass.states.async_set("lock.outside_lock_2", STATE_LOCKED) hass.states.async_set("lock.outside_lock_2", LockState.LOCKED)
yaml_path = get_fixture_path("configuration.yaml", "group") yaml_path = get_fixture_path("configuration.yaml", "group")
with patch.object(hass_config, "YAML_CONFIG_FILE", yaml_path): 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.lock_group") is None
assert hass.states.get("lock.inside_locks_g") is not 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.outside_locks_g") is not None
assert hass.states.get("lock.inside_locks_g").state == STATE_UNLOCKED assert hass.states.get("lock.inside_locks_g").state == LockState.UNLOCKED
assert hass.states.get("lock.outside_locks_g").state == STATE_LOCKED assert hass.states.get("lock.outside_locks_g").state == LockState.LOCKED
@patch.object(demo_lock, "LOCK_UNLOCK_DELAY", 0) @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") state = hass.states.get("lock.some_group")
assert state is not None assert state is not None
assert state.state == STATE_UNLOCKED assert state.state == LockState.UNLOCKED
assert state.attributes.get(ATTR_ENTITY_ID) == [ assert state.attributes.get(ATTR_ENTITY_ID) == [
"lock.front_door", "lock.front_door",
"lock.kitchen_door", "lock.kitchen_door",
@ -434,7 +425,7 @@ async def test_nested_group(hass: HomeAssistant) -> None:
state = hass.states.get("lock.nested_group") state = hass.states.get("lock.nested_group")
assert state is not None 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"] assert state.attributes.get(ATTR_ENTITY_ID) == ["lock.some_group"]
# Test controlling the nested group # Test controlling the nested group
@ -444,7 +435,7 @@ async def test_nested_group(hass: HomeAssistant) -> None:
{ATTR_ENTITY_ID: "lock.nested_group"}, {ATTR_ENTITY_ID: "lock.nested_group"},
blocking=True, blocking=True,
) )
assert hass.states.get("lock.front_door").state == STATE_LOCKED assert hass.states.get("lock.front_door").state == LockState.LOCKED
assert hass.states.get("lock.kitchen_door").state == STATE_LOCKED assert hass.states.get("lock.kitchen_door").state == LockState.LOCKED
assert hass.states.get("lock.some_group").state == STATE_LOCKED assert hass.states.get("lock.some_group").state == LockState.LOCKED
assert hass.states.get("lock.nested_group").state == STATE_LOCKED assert hass.states.get("lock.nested_group").state == LockState.LOCKED

21
tests/components/homekit/test_type_locks.py
View File

@ -4,19 +4,12 @@ import pytest
from homeassistant.components.homekit.const import ATTR_VALUE from homeassistant.components.homekit.const import ATTR_VALUE
from homeassistant.components.homekit.type_locks import Lock from homeassistant.components.homekit.type_locks import Lock
from homeassistant.components.lock import ( from homeassistant.components.lock import DOMAIN as LOCK_DOMAIN, LockState
DOMAIN as LOCK_DOMAIN,
STATE_JAMMED,
STATE_LOCKING,
STATE_UNLOCKING,
)
from homeassistant.const import ( from homeassistant.const import (
ATTR_CODE, ATTR_CODE,
ATTR_ENTITY_ID, ATTR_ENTITY_ID,
STATE_LOCKED,
STATE_UNAVAILABLE, STATE_UNAVAILABLE,
STATE_UNKNOWN, STATE_UNKNOWN,
STATE_UNLOCKED,
) )
from homeassistant.core import Event, HomeAssistant 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_current_state.value == 3
assert acc.char_target_state.value == 1 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() await hass.async_block_till_done()
assert acc.char_current_state.value == 1 assert acc.char_current_state.value == 1
assert acc.char_target_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() await hass.async_block_till_done()
assert acc.char_current_state.value == 0 assert acc.char_current_state.value == 0
assert acc.char_target_state.value == 1 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() await hass.async_block_till_done()
assert acc.char_current_state.value == 0 assert acc.char_current_state.value == 0
assert acc.char_target_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() await hass.async_block_till_done()
assert acc.char_current_state.value == 1 assert acc.char_current_state.value == 1
assert acc.char_target_state.value == 0 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() await hass.async_block_till_done()
assert acc.char_current_state.value == 2 assert acc.char_current_state.value == 2
assert acc.char_target_state.value == 0 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.char_target_state.value == 0
assert acc.available is False 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() await hass.async_block_till_done()
assert acc.char_current_state.value == 0 assert acc.char_current_state.value == 0
assert acc.char_target_state.value == 0 assert acc.char_target_state.value == 0

15
tests/components/homematicip_cloud/test_lock.py
View File

@ -2,15 +2,14 @@
from unittest.mock import patch from unittest.mock import patch
from homematicip.base.enums import LockState, MotorState from homematicip.base.enums import LockState as HomematicLockState, MotorState
import pytest import pytest
from homeassistant.components.homematicip_cloud import DOMAIN as HMIPC_DOMAIN from homeassistant.components.homematicip_cloud import DOMAIN as HMIPC_DOMAIN
from homeassistant.components.lock import ( from homeassistant.components.lock import (
DOMAIN as LOCK_DOMAIN, DOMAIN as LOCK_DOMAIN,
STATE_LOCKING,
STATE_UNLOCKING,
LockEntityFeature, LockEntityFeature,
LockState,
) )
from homeassistant.const import ATTR_SUPPORTED_FEATURES from homeassistant.const import ATTR_SUPPORTED_FEATURES
from homeassistant.core import HomeAssistant from homeassistant.core import HomeAssistant
@ -52,7 +51,7 @@ async def test_hmip_doorlockdrive(
blocking=True, blocking=True,
) )
assert hmip_device.mock_calls[-1][0] == "set_lock_state" 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( await hass.services.async_call(
"lock", "lock",
@ -61,7 +60,7 @@ async def test_hmip_doorlockdrive(
blocking=True, blocking=True,
) )
assert hmip_device.mock_calls[-1][0] == "set_lock_state" 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( await hass.services.async_call(
"lock", "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][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( await async_manipulate_test_data(
hass, hmip_device, "motorState", MotorState.CLOSING hass, hmip_device, "motorState", MotorState.CLOSING
) )
ha_state = hass.states.get(entity_id) ha_state = hass.states.get(entity_id)
assert ha_state.state == STATE_LOCKING assert ha_state.state == LockState.LOCKING
await async_manipulate_test_data( await async_manipulate_test_data(
hass, hmip_device, "motorState", MotorState.OPENING hass, hmip_device, "motorState", MotorState.OPENING
) )
ha_state = hass.states.get(entity_id) 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( async def test_hmip_doorlockdrive_handle_errors(

15
tests/components/insteon/test_lock.py
View File

@ -10,15 +10,8 @@ from homeassistant.components.insteon import (
entity as insteon_entity, entity as insteon_entity,
utils as insteon_utils, utils as insteon_utils,
) )
from homeassistant.components.lock import ( # SERVICE_LOCK,; SERVICE_UNLOCK, from homeassistant.components.lock import DOMAIN as LOCK_DOMAIN, LockState
DOMAIN as LOCK_DOMAIN, from homeassistant.const import EVENT_HOMEASSISTANT_STOP, Platform
)
from homeassistant.const import ( # ATTR_ENTITY_ID,;
EVENT_HOMEASSISTANT_STOP,
STATE_LOCKED,
STATE_UNLOCKED,
Platform,
)
from homeassistant.core import HomeAssistant from homeassistant.core import HomeAssistant
from homeassistant.helpers import entity_registry as er from homeassistant.helpers import entity_registry as er
@ -73,7 +66,7 @@ async def test_lock_lock(
try: try:
lock = entity_registry.async_get("lock.device_55_55_55_55_55_55") lock = entity_registry.async_get("lock.device_55_55_55_55_55_55")
state = hass.states.get(lock.entity_id) state = hass.states.get(lock.entity_id)
assert state.state is STATE_UNLOCKED assert state.state == LockState.UNLOCKED
# lock via UI # lock via UI
await hass.services.async_call( 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") lock = entity_registry.async_get("lock.device_55_55_55_55_55_55")
state = hass.states.get(lock.entity_id) state = hass.states.get(lock.entity_id)
assert state.state is STATE_LOCKED assert state.state == LockState.LOCKED
# lock via UI # lock via UI
await hass.services.async_call( await hass.services.async_call(

26
tests/components/kitchen_sink/test_lock.py
View File

@ -11,17 +11,9 @@ from homeassistant.components.lock import (
SERVICE_LOCK, SERVICE_LOCK,
SERVICE_OPEN, SERVICE_OPEN,
SERVICE_UNLOCK, SERVICE_UNLOCK,
STATE_LOCKED, LockState,
STATE_LOCKING,
STATE_UNLOCKED,
STATE_UNLOCKING,
)
from homeassistant.const import (
ATTR_ENTITY_ID,
EVENT_STATE_CHANGED,
STATE_OPEN,
Platform,
) )
from homeassistant.const import ATTR_ENTITY_ID, EVENT_STATE_CHANGED, Platform
from homeassistant.core import HomeAssistant from homeassistant.core import HomeAssistant
from homeassistant.setup import async_setup_component 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: async def test_locking(hass: HomeAssistant) -> None:
"""Test the locking of a lock.""" """Test the locking of a lock."""
state = hass.states.get(UNLOCKED_LOCK) state = hass.states.get(UNLOCKED_LOCK)
assert state.state == STATE_UNLOCKED assert state.state == LockState.UNLOCKED
await hass.async_block_till_done() await hass.async_block_till_done()
state_changes = async_capture_events(hass, EVENT_STATE_CHANGED) 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() await hass.async_block_till_done()
assert state_changes[0].data["entity_id"] == UNLOCKED_LOCK 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["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: async def test_unlocking(hass: HomeAssistant) -> None:
"""Test the unlocking of a lock.""" """Test the unlocking of a lock."""
state = hass.states.get(LOCKED_LOCK) state = hass.states.get(LOCKED_LOCK)
assert state.state == STATE_LOCKED assert state.state == LockState.LOCKED
await hass.async_block_till_done() await hass.async_block_till_done()
state_changes = async_capture_events(hass, EVENT_STATE_CHANGED) 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() await hass.async_block_till_done()
assert state_changes[0].data["entity_id"] == LOCKED_LOCK 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["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: 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 LOCK_DOMAIN, SERVICE_OPEN, {ATTR_ENTITY_ID: OPENABLE_LOCK}, blocking=True
) )
state = hass.states.get(OPENABLE_LOCK) state = hass.states.get(OPENABLE_LOCK)
assert state.state == STATE_OPEN assert state.state == LockState.OPEN

29
tests/components/lock/test_device_condition.py
View File

@ -5,17 +5,8 @@ from pytest_unordered import unordered
from homeassistant.components import automation from homeassistant.components import automation
from homeassistant.components.device_automation import DeviceAutomationType from homeassistant.components.device_automation import DeviceAutomationType
from homeassistant.components.lock import DOMAIN from homeassistant.components.lock import DOMAIN, LockState
from homeassistant.const import ( from homeassistant.const import EntityCategory
STATE_JAMMED,
STATE_LOCKED,
STATE_LOCKING,
STATE_OPEN,
STATE_OPENING,
STATE_UNLOCKED,
STATE_UNLOCKING,
EntityCategory,
)
from homeassistant.core import HomeAssistant, ServiceCall from homeassistant.core import HomeAssistant, ServiceCall
from homeassistant.helpers import device_registry as dr, entity_registry as er from homeassistant.helpers import device_registry as dr, entity_registry as er
from homeassistant.helpers.entity_registry import RegistryEntryHider from homeassistant.helpers.entity_registry import RegistryEntryHider
@ -142,7 +133,7 @@ async def test_if_state(
DOMAIN, "test", "5678", device_id=device_entry.id 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( assert await async_setup_component(
hass, hass,
@ -284,38 +275,38 @@ async def test_if_state(
assert len(service_calls) == 1 assert len(service_calls) == 1
assert service_calls[0].data["some"] == "is_locked - event - test_event1" 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_event1")
hass.bus.async_fire("test_event2") hass.bus.async_fire("test_event2")
await hass.async_block_till_done() await hass.async_block_till_done()
assert len(service_calls) == 2 assert len(service_calls) == 2
assert service_calls[1].data["some"] == "is_unlocked - event - test_event2" 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") hass.bus.async_fire("test_event3")
await hass.async_block_till_done() await hass.async_block_till_done()
assert len(service_calls) == 3 assert len(service_calls) == 3
assert service_calls[2].data["some"] == "is_unlocking - event - test_event3" 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") hass.bus.async_fire("test_event4")
await hass.async_block_till_done() await hass.async_block_till_done()
assert len(service_calls) == 4 assert len(service_calls) == 4
assert service_calls[3].data["some"] == "is_locking - event - test_event4" 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") hass.bus.async_fire("test_event5")
await hass.async_block_till_done() await hass.async_block_till_done()
assert len(service_calls) == 5 assert len(service_calls) == 5
assert service_calls[4].data["some"] == "is_jammed - event - test_event5" 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") hass.bus.async_fire("test_event6")
await hass.async_block_till_done() await hass.async_block_till_done()
assert len(service_calls) == 6 assert len(service_calls) == 6
assert service_calls[5].data["some"] == "is_opening - event - test_event6" 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") hass.bus.async_fire("test_event7")
await hass.async_block_till_done() await hass.async_block_till_done()
assert len(service_calls) == 7 assert len(service_calls) == 7
@ -339,7 +330,7 @@ async def test_if_state_legacy(
DOMAIN, "test", "5678", device_id=device_entry.id 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( assert await async_setup_component(
hass, hass,

37
tests/components/lock/test_device_trigger.py
View File

@ -7,17 +7,8 @@ from pytest_unordered import unordered
from homeassistant.components import automation from homeassistant.components import automation
from homeassistant.components.device_automation import DeviceAutomationType from homeassistant.components.device_automation import DeviceAutomationType
from homeassistant.components.lock import DOMAIN, LockEntityFeature from homeassistant.components.lock import DOMAIN, LockEntityFeature, LockState
from homeassistant.const import ( from homeassistant.const import EntityCategory
STATE_JAMMED,
STATE_LOCKED,
STATE_LOCKING,
STATE_OPEN,
STATE_OPENING,
STATE_UNLOCKED,
STATE_UNLOCKING,
EntityCategory,
)
from homeassistant.core import HomeAssistant, ServiceCall from homeassistant.core import HomeAssistant, ServiceCall
from homeassistant.helpers import device_registry as dr, entity_registry as er from homeassistant.helpers import device_registry as dr, entity_registry as er
from homeassistant.helpers.entity_registry import RegistryEntryHider 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 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( assert await async_setup_component(
hass, hass,
@ -287,7 +278,7 @@ async def test_if_fires_on_state_change(
) )
# Fake that the entity is turning on. # 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() await hass.async_block_till_done()
assert len(service_calls) == 1 assert len(service_calls) == 1
assert ( assert (
@ -296,7 +287,7 @@ async def test_if_fires_on_state_change(
) )
# Fake that the entity is turning off. # 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() await hass.async_block_till_done()
assert len(service_calls) == 2 assert len(service_calls) == 2
assert ( assert (
@ -305,7 +296,7 @@ async def test_if_fires_on_state_change(
) )
# Fake that the entity is opens. # 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() await hass.async_block_till_done()
assert len(service_calls) == 3 assert len(service_calls) == 3
assert ( assert (
@ -331,7 +322,7 @@ async def test_if_fires_on_state_change_legacy(
DOMAIN, "test", "5678", device_id=device_entry.id 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( assert await async_setup_component(
hass, hass,
@ -362,7 +353,7 @@ async def test_if_fires_on_state_change_legacy(
) )
# Fake that the entity is turning on. # 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() await hass.async_block_till_done()
assert len(service_calls) == 1 assert len(service_calls) == 1
assert ( assert (
@ -388,7 +379,7 @@ async def test_if_fires_on_state_change_with_for(
DOMAIN, "test", "5678", device_id=device_entry.id 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( assert await async_setup_component(
hass, hass,
@ -511,7 +502,7 @@ async def test_if_fires_on_state_change_with_for(
await hass.async_block_till_done() await hass.async_block_till_done()
assert len(service_calls) == 0 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() await hass.async_block_till_done()
assert len(service_calls) == 0 assert len(service_calls) == 0
async_fire_time_changed(hass, dt_util.utcnow() + timedelta(seconds=10)) 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" == 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() await hass.async_block_till_done()
assert len(service_calls) == 1 assert len(service_calls) == 1
async_fire_time_changed(hass, dt_util.utcnow() + timedelta(seconds=16)) 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" == 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() await hass.async_block_till_done()
assert len(service_calls) == 2 assert len(service_calls) == 2
async_fire_time_changed(hass, dt_util.utcnow() + timedelta(seconds=21)) 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" == 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() await hass.async_block_till_done()
assert len(service_calls) == 3 assert len(service_calls) == 3
async_fire_time_changed(hass, dt_util.utcnow() + timedelta(seconds=27)) 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" == 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() await hass.async_block_till_done()
assert len(service_calls) == 4 assert len(service_calls) == 4
async_fire_time_changed(hass, dt_util.utcnow() + timedelta(seconds=27)) async_fire_time_changed(hass, dt_util.utcnow() + timedelta(seconds=27))

50
tests/components/lock/test_init.py
View File

@ -2,6 +2,7 @@
from __future__ import annotations from __future__ import annotations
from enum import Enum
import re import re
from typing import Any from typing import Any
@ -15,14 +16,9 @@ from homeassistant.components.lock import (
SERVICE_LOCK, SERVICE_LOCK,
SERVICE_OPEN, SERVICE_OPEN,
SERVICE_UNLOCK, SERVICE_UNLOCK,
STATE_JAMMED,
STATE_LOCKED,
STATE_LOCKING,
STATE_UNLOCKED,
STATE_UNLOCKING,
LockEntityFeature, LockEntityFeature,
LockState,
) )
from homeassistant.const import STATE_OPEN, STATE_OPENING
from homeassistant.core import HomeAssistant from homeassistant.core import HomeAssistant
from homeassistant.exceptions import ServiceValidationError from homeassistant.exceptions import ServiceValidationError
import homeassistant.helpers.entity_registry as er 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 mock_lock_entity._attr_is_locking = True
assert mock_lock_entity.is_locking 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_locked = True
mock_lock_entity._attr_is_locking = False mock_lock_entity._attr_is_locking = False
assert mock_lock_entity.is_locked 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 mock_lock_entity._attr_is_unlocking = True
assert mock_lock_entity.is_unlocking 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_locked = False
mock_lock_entity._attr_is_unlocking = False mock_lock_entity._attr_is_unlocking = False
assert not mock_lock_entity.is_locked 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 mock_lock_entity._attr_is_jammed = True
assert mock_lock_entity.is_jammed 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 assert not mock_lock_entity.is_locked
mock_lock_entity._attr_is_jammed = False mock_lock_entity._attr_is_jammed = False
mock_lock_entity._attr_is_opening = True mock_lock_entity._attr_is_opening = True
assert mock_lock_entity.is_opening 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 assert mock_lock_entity.is_opening
mock_lock_entity._attr_is_opening = False mock_lock_entity._attr_is_opening = False
mock_lock_entity._attr_is_open = True mock_lock_entity._attr_is_open = True
assert not mock_lock_entity.is_opening 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 not mock_lock_entity.is_opening
assert mock_lock_entity.is_open assert mock_lock_entity.is_open
@ -393,13 +389,35 @@ def test_all() -> None:
help_test_all(lock) 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( def test_deprecated_constants(
caplog: pytest.LogCaptureFixture, caplog: pytest.LogCaptureFixture,
enum: LockEntityFeature, enum: Enum,
constant_prefix: str,
remove_in_version: str,
) -> None: ) -> None:
"""Test deprecated constants.""" """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: def test_deprecated_supported_features_ints(caplog: pytest.LogCaptureFixture) -> None:

7
tests/components/loqed/test_lock.py
View File

@ -2,6 +2,7 @@
from loqedAPI import loqed from loqedAPI import loqed
from homeassistant.components.lock import LockState
from homeassistant.components.loqed import LoqedDataCoordinator from homeassistant.components.loqed import LoqedDataCoordinator
from homeassistant.components.loqed.const import DOMAIN from homeassistant.components.loqed.const import DOMAIN
from homeassistant.const import ( from homeassistant.const import (
@ -9,8 +10,6 @@ from homeassistant.const import (
SERVICE_LOCK, SERVICE_LOCK,
SERVICE_OPEN, SERVICE_OPEN,
SERVICE_UNLOCK, SERVICE_UNLOCK,
STATE_LOCKED,
STATE_UNLOCKED,
) )
from homeassistant.core import HomeAssistant from homeassistant.core import HomeAssistant
@ -27,7 +26,7 @@ async def test_lock_entity(
state = hass.states.get(entity_id) state = hass.states.get(entity_id)
assert state assert state
assert state.state == STATE_UNLOCKED assert state.state == LockState.UNLOCKED
async def test_lock_responds_to_bolt_state_updates( 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) state = hass.states.get(entity_id)
assert state assert state
assert state.state == STATE_LOCKED assert state.state == LockState.LOCKED
async def test_lock_transition_to_unlocked( async def test_lock_transition_to_unlocked(

25
tests/components/matter/test_lock.py
View File

@ -6,13 +6,8 @@ from chip.clusters import Objects as clusters
from matter_server.client.models.node import MatterNode from matter_server.client.models.node import MatterNode
import pytest import pytest
from homeassistant.components.lock import ( from homeassistant.components.lock import LockEntityFeature, LockState
STATE_LOCKED, from homeassistant.const import ATTR_CODE, STATE_UNKNOWN
STATE_OPEN,
STATE_UNLOCKED,
LockEntityFeature,
)
from homeassistant.const import ATTR_CODE, STATE_LOCKING, STATE_OPENING, STATE_UNKNOWN
from homeassistant.core import HomeAssistant from homeassistant.core import HomeAssistant
from homeassistant.exceptions import ServiceValidationError from homeassistant.exceptions import ServiceValidationError
import homeassistant.helpers.entity_registry as er import homeassistant.helpers.entity_registry as er
@ -67,28 +62,28 @@ async def test_lock(
await hass.async_block_till_done() await hass.async_block_till_done()
state = hass.states.get("lock.mock_door_lock_lock") state = hass.states.get("lock.mock_door_lock_lock")
assert state assert state
assert state.state == STATE_LOCKING assert state.state == LockState.LOCKING
set_node_attribute(door_lock, 1, 257, 0, 0) set_node_attribute(door_lock, 1, 257, 0, 0)
await trigger_subscription_callback(hass, matter_client) await trigger_subscription_callback(hass, matter_client)
state = hass.states.get("lock.mock_door_lock_lock") state = hass.states.get("lock.mock_door_lock_lock")
assert state assert state
assert state.state == STATE_UNLOCKED assert state.state == LockState.UNLOCKED
set_node_attribute(door_lock, 1, 257, 0, 2) set_node_attribute(door_lock, 1, 257, 0, 2)
await trigger_subscription_callback(hass, matter_client) await trigger_subscription_callback(hass, matter_client)
state = hass.states.get("lock.mock_door_lock_lock") state = hass.states.get("lock.mock_door_lock_lock")
assert state assert state
assert state.state == STATE_UNLOCKED assert state.state == LockState.UNLOCKED
set_node_attribute(door_lock, 1, 257, 0, 1) set_node_attribute(door_lock, 1, 257, 0, 1)
await trigger_subscription_callback(hass, matter_client) await trigger_subscription_callback(hass, matter_client)
state = hass.states.get("lock.mock_door_lock_lock") state = hass.states.get("lock.mock_door_lock_lock")
assert state assert state
assert state.state == STATE_LOCKED assert state.state == LockState.LOCKED
set_node_attribute(door_lock, 1, 257, 0, None) set_node_attribute(door_lock, 1, 257, 0, None)
await trigger_subscription_callback(hass, matter_client) await trigger_subscription_callback(hass, matter_client)
@ -178,7 +173,7 @@ async def test_lock_with_unbolt(
"""Test door lock.""" """Test door lock."""
state = hass.states.get("lock.mock_door_lock_lock") state = hass.states.get("lock.mock_door_lock_lock")
assert state assert state
assert state.state == STATE_LOCKED assert state.state == LockState.LOCKED
assert state.attributes["supported_features"] & LockEntityFeature.OPEN assert state.attributes["supported_features"] & LockEntityFeature.OPEN
# test unlock/unbolt # test unlock/unbolt
await hass.services.async_call( await hass.services.async_call(
@ -218,18 +213,18 @@ async def test_lock_with_unbolt(
await hass.async_block_till_done() await hass.async_block_till_done()
state = hass.states.get("lock.mock_door_lock_lock") state = hass.states.get("lock.mock_door_lock_lock")
assert state assert state
assert state.state == STATE_OPENING assert state.state == LockState.OPENING
set_node_attribute(door_lock_with_unbolt, 1, 257, 0, 0) set_node_attribute(door_lock_with_unbolt, 1, 257, 0, 0)
await trigger_subscription_callback(hass, matter_client) await trigger_subscription_callback(hass, matter_client)
state = hass.states.get("lock.mock_door_lock_lock") state = hass.states.get("lock.mock_door_lock_lock")
assert state assert state
assert state.state == STATE_UNLOCKED assert state.state == LockState.UNLOCKED
set_node_attribute(door_lock_with_unbolt, 1, 257, 0, 3) set_node_attribute(door_lock_with_unbolt, 1, 257, 0, 3)
await trigger_subscription_callback(hass, matter_client) await trigger_subscription_callback(hass, matter_client)
state = hass.states.get("lock.mock_door_lock_lock") state = hass.states.get("lock.mock_door_lock_lock")
assert state assert state
assert state.state == STATE_OPEN assert state.state == LockState.OPEN

112
tests/components/mqtt/test_lock.py
View File

@ -10,14 +10,8 @@ from homeassistant.components.lock import (
SERVICE_LOCK, SERVICE_LOCK,
SERVICE_OPEN, SERVICE_OPEN,
SERVICE_UNLOCK, SERVICE_UNLOCK,
STATE_JAMMED,
STATE_LOCKED,
STATE_LOCKING,
STATE_OPEN,
STATE_OPENING,
STATE_UNLOCKED,
STATE_UNLOCKING,
LockEntityFeature, LockEntityFeature,
LockState,
) )
from homeassistant.components.mqtt.lock import MQTT_LOCK_ATTRIBUTES_BLOCKED from homeassistant.components.mqtt.lock import MQTT_LOCK_ATTRIBUTES_BLOCKED
from homeassistant.const import ( from homeassistant.const import (
@ -89,12 +83,12 @@ CONFIG_WITH_STATES = {
@pytest.mark.parametrize( @pytest.mark.parametrize(
("hass_config", "payload", "lock_state"), ("hass_config", "payload", "lock_state"),
[ [
(CONFIG_WITH_STATES, "closed", STATE_LOCKED), (CONFIG_WITH_STATES, "closed", LockState.LOCKED),
(CONFIG_WITH_STATES, "closing", STATE_LOCKING), (CONFIG_WITH_STATES, "closing", LockState.LOCKING),
(CONFIG_WITH_STATES, "open", STATE_OPEN), (CONFIG_WITH_STATES, "open", LockState.OPEN),
(CONFIG_WITH_STATES, "opening", STATE_OPENING), (CONFIG_WITH_STATES, "opening", LockState.OPENING),
(CONFIG_WITH_STATES, "unlocked", STATE_UNLOCKED), (CONFIG_WITH_STATES, "unlocked", LockState.UNLOCKED),
(CONFIG_WITH_STATES, "unlocking", STATE_UNLOCKING), (CONFIG_WITH_STATES, "unlocking", LockState.UNLOCKING),
], ],
) )
async def test_controlling_state_via_topic( async def test_controlling_state_via_topic(
@ -115,18 +109,18 @@ async def test_controlling_state_via_topic(
await hass.async_block_till_done() await hass.async_block_till_done()
state = hass.states.get("lock.test") state = hass.states.get("lock.test")
assert state.state is lock_state assert state.state == lock_state
@pytest.mark.parametrize( @pytest.mark.parametrize(
("hass_config", "payload", "lock_state"), ("hass_config", "payload", "lock_state"),
[ [
(CONFIG_WITH_STATES, "closed", STATE_LOCKED), (CONFIG_WITH_STATES, "closed", LockState.LOCKED),
(CONFIG_WITH_STATES, "closing", STATE_LOCKING), (CONFIG_WITH_STATES, "closing", LockState.LOCKING),
(CONFIG_WITH_STATES, "open", STATE_OPEN), (CONFIG_WITH_STATES, "open", LockState.OPEN),
(CONFIG_WITH_STATES, "opening", STATE_OPENING), (CONFIG_WITH_STATES, "opening", LockState.OPENING),
(CONFIG_WITH_STATES, "unlocked", STATE_UNLOCKED), (CONFIG_WITH_STATES, "unlocked", LockState.UNLOCKED),
(CONFIG_WITH_STATES, "unlocking", STATE_UNLOCKING), (CONFIG_WITH_STATES, "unlocking", LockState.UNLOCKING),
(CONFIG_WITH_STATES, "None", STATE_UNKNOWN), (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) async_fire_mqtt_message(hass, "state-topic", payload)
state = hass.states.get("lock.test") state = hass.states.get("lock.test")
assert state.state is lock_state assert state.state == lock_state
# Empty state is ignored # Empty state is ignored
async_fire_mqtt_message(hass, "state-topic", "") async_fire_mqtt_message(hass, "state-topic", "")
state = hass.states.get("lock.test") state = hass.states.get("lock.test")
assert state.state is lock_state assert state.state == lock_state
@pytest.mark.parametrize( @pytest.mark.parametrize(
@ -165,7 +159,7 @@ async def test_controlling_non_default_state_via_topic(
({"value_template": "{{ value_json.val }}"},), ({"value_template": "{{ value_json.val }}"},),
), ),
'{"val":"closed"}', '{"val":"closed"}',
STATE_LOCKED, LockState.LOCKED,
), ),
( (
help_custom_config( help_custom_config(
@ -174,7 +168,7 @@ async def test_controlling_non_default_state_via_topic(
({"value_template": "{{ value_json.val }}"},), ({"value_template": "{{ value_json.val }}"},),
), ),
'{"val":"closing"}', '{"val":"closing"}',
STATE_LOCKING, LockState.LOCKING,
), ),
( (
help_custom_config( help_custom_config(
@ -183,7 +177,7 @@ async def test_controlling_non_default_state_via_topic(
({"value_template": "{{ value_json.val }}"},), ({"value_template": "{{ value_json.val }}"},),
), ),
'{"val":"unlocking"}', '{"val":"unlocking"}',
STATE_UNLOCKING, LockState.UNLOCKING,
), ),
( (
help_custom_config( help_custom_config(
@ -192,7 +186,7 @@ async def test_controlling_non_default_state_via_topic(
({"value_template": "{{ value_json.val }}"},), ({"value_template": "{{ value_json.val }}"},),
), ),
'{"val":"open"}', '{"val":"open"}',
STATE_OPEN, LockState.OPEN,
), ),
( (
help_custom_config( help_custom_config(
@ -201,7 +195,7 @@ async def test_controlling_non_default_state_via_topic(
({"value_template": "{{ value_json.val }}"},), ({"value_template": "{{ value_json.val }}"},),
), ),
'{"val":"opening"}', '{"val":"opening"}',
STATE_OPENING, LockState.OPENING,
), ),
( (
help_custom_config( help_custom_config(
@ -210,7 +204,7 @@ async def test_controlling_non_default_state_via_topic(
({"value_template": "{{ value_json.val }}"},), ({"value_template": "{{ value_json.val }}"},),
), ),
'{"val":"unlocked"}', '{"val":"unlocked"}',
STATE_UNLOCKED, LockState.UNLOCKED,
), ),
( (
help_custom_config( 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) async_fire_mqtt_message(hass, "state-topic", payload)
state = hass.states.get("lock.test") state = hass.states.get("lock.test")
assert state.state is lock_state assert state.state == lock_state
@pytest.mark.parametrize( @pytest.mark.parametrize(
@ -251,7 +245,7 @@ async def test_controlling_state_via_topic_and_json_message(
({"value_template": "{{ value_json.val }}"},), ({"value_template": "{{ value_json.val }}"},),
), ),
'{"val":"closed"}', '{"val":"closed"}',
STATE_LOCKED, LockState.LOCKED,
), ),
( (
help_custom_config( help_custom_config(
@ -260,7 +254,7 @@ async def test_controlling_state_via_topic_and_json_message(
({"value_template": "{{ value_json.val }}"},), ({"value_template": "{{ value_json.val }}"},),
), ),
'{"val":"closing"}', '{"val":"closing"}',
STATE_LOCKING, LockState.LOCKING,
), ),
( (
help_custom_config( help_custom_config(
@ -269,7 +263,7 @@ async def test_controlling_state_via_topic_and_json_message(
({"value_template": "{{ value_json.val }}"},), ({"value_template": "{{ value_json.val }}"},),
), ),
'{"val":"open"}', '{"val":"open"}',
STATE_OPEN, LockState.OPEN,
), ),
( (
help_custom_config( help_custom_config(
@ -278,7 +272,7 @@ async def test_controlling_state_via_topic_and_json_message(
({"value_template": "{{ value_json.val }}"},), ({"value_template": "{{ value_json.val }}"},),
), ),
'{"val":"opening"}', '{"val":"opening"}',
STATE_OPENING, LockState.OPENING,
), ),
( (
help_custom_config( help_custom_config(
@ -287,7 +281,7 @@ async def test_controlling_state_via_topic_and_json_message(
({"value_template": "{{ value_json.val }}"},), ({"value_template": "{{ value_json.val }}"},),
), ),
'{"val":"unlocked"}', '{"val":"unlocked"}',
STATE_UNLOCKED, LockState.UNLOCKED,
), ),
( (
help_custom_config( help_custom_config(
@ -296,7 +290,7 @@ async def test_controlling_state_via_topic_and_json_message(
({"value_template": "{{ value_json.val }}"},), ({"value_template": "{{ value_json.val }}"},),
), ),
'{"val":"unlocking"}', '{"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) async_fire_mqtt_message(hass, "state-topic", payload)
state = hass.states.get("lock.test") state = hass.states.get("lock.test")
assert state.state is lock_state assert state.state == lock_state
@pytest.mark.parametrize( @pytest.mark.parametrize(
@ -342,7 +336,7 @@ async def test_sending_mqtt_commands_and_optimistic(
mqtt_mock = await mqtt_mock_entry() mqtt_mock = await mqtt_mock_entry()
state = hass.states.get("lock.test") 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_ASSUMED_STATE)
await hass.services.async_call( 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.assert_called_once_with("command-topic", "LOCK", 0, False)
mqtt_mock.async_publish.reset_mock() mqtt_mock.async_publish.reset_mock()
state = hass.states.get("lock.test") state = hass.states.get("lock.test")
assert state.state is STATE_LOCKED assert state.state == LockState.LOCKED
assert state.attributes.get(ATTR_ASSUMED_STATE) assert state.attributes.get(ATTR_ASSUMED_STATE)
await hass.services.async_call( 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.assert_called_once_with("command-topic", "UNLOCK", 0, False)
mqtt_mock.async_publish.reset_mock() mqtt_mock.async_publish.reset_mock()
state = hass.states.get("lock.test") 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_ASSUMED_STATE)
@ -393,7 +387,7 @@ async def test_sending_mqtt_commands_with_template(
mqtt_mock = await mqtt_mock_entry() mqtt_mock = await mqtt_mock_entry()
state = hass.states.get("lock.test") 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_ASSUMED_STATE)
await hass.services.async_call( await hass.services.async_call(
@ -408,7 +402,7 @@ async def test_sending_mqtt_commands_with_template(
) )
mqtt_mock.async_publish.reset_mock() mqtt_mock.async_publish.reset_mock()
state = hass.states.get("lock.test") state = hass.states.get("lock.test")
assert state.state is STATE_LOCKED assert state.state == LockState.LOCKED
assert state.attributes.get(ATTR_ASSUMED_STATE) assert state.attributes.get(ATTR_ASSUMED_STATE)
await hass.services.async_call( await hass.services.async_call(
@ -423,7 +417,7 @@ async def test_sending_mqtt_commands_with_template(
) )
mqtt_mock.async_publish.reset_mock() mqtt_mock.async_publish.reset_mock()
state = hass.states.get("lock.test") 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_ASSUMED_STATE)
@ -453,7 +447,7 @@ async def test_sending_mqtt_commands_and_explicit_optimistic(
mqtt_mock = await mqtt_mock_entry() mqtt_mock = await mqtt_mock_entry()
state = hass.states.get("lock.test") 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_ASSUMED_STATE)
await hass.services.async_call( 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.assert_called_once_with("command-topic", "LOCK", 0, False)
mqtt_mock.async_publish.reset_mock() mqtt_mock.async_publish.reset_mock()
state = hass.states.get("lock.test") state = hass.states.get("lock.test")
assert state.state is STATE_LOCKED assert state.state == LockState.LOCKED
assert state.attributes.get(ATTR_ASSUMED_STATE) assert state.attributes.get(ATTR_ASSUMED_STATE)
await hass.services.async_call( 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.assert_called_once_with("command-topic", "UNLOCK", 0, False)
mqtt_mock.async_publish.reset_mock() mqtt_mock.async_publish.reset_mock()
state = hass.states.get("lock.test") 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_ASSUMED_STATE)
@ -502,7 +496,7 @@ async def test_sending_mqtt_commands_support_open_and_optimistic(
mqtt_mock = await mqtt_mock_entry() mqtt_mock = await mqtt_mock_entry()
state = hass.states.get("lock.test") 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_ASSUMED_STATE)
assert state.attributes.get(ATTR_SUPPORTED_FEATURES) == LockEntityFeature.OPEN 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.assert_called_once_with("command-topic", "LOCK", 0, False)
mqtt_mock.async_publish.reset_mock() mqtt_mock.async_publish.reset_mock()
state = hass.states.get("lock.test") state = hass.states.get("lock.test")
assert state.state is STATE_LOCKED assert state.state == LockState.LOCKED
assert state.attributes.get(ATTR_ASSUMED_STATE) assert state.attributes.get(ATTR_ASSUMED_STATE)
await hass.services.async_call( 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.assert_called_once_with("command-topic", "UNLOCK", 0, False)
mqtt_mock.async_publish.reset_mock() mqtt_mock.async_publish.reset_mock()
state = hass.states.get("lock.test") 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_ASSUMED_STATE)
await hass.services.async_call( 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.assert_called_once_with("command-topic", "OPEN", 0, False)
mqtt_mock.async_publish.reset_mock() mqtt_mock.async_publish.reset_mock()
state = hass.states.get("lock.test") state = hass.states.get("lock.test")
assert state.state is STATE_OPEN assert state.state == LockState.OPEN
assert state.attributes.get(ATTR_ASSUMED_STATE) 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() mqtt_mock = await mqtt_mock_entry()
state = hass.states.get("lock.test") 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_ASSUMED_STATE)
assert state.attributes.get(ATTR_SUPPORTED_FEATURES) == LockEntityFeature.OPEN 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.assert_called_once_with("command-topic", "LOCK", 0, False)
mqtt_mock.async_publish.reset_mock() mqtt_mock.async_publish.reset_mock()
state = hass.states.get("lock.test") state = hass.states.get("lock.test")
assert state.state is STATE_LOCKED assert state.state == LockState.LOCKED
assert state.attributes.get(ATTR_ASSUMED_STATE) assert state.attributes.get(ATTR_ASSUMED_STATE)
await hass.services.async_call( 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.assert_called_once_with("command-topic", "UNLOCK", 0, False)
mqtt_mock.async_publish.reset_mock() mqtt_mock.async_publish.reset_mock()
state = hass.states.get("lock.test") 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_ASSUMED_STATE)
await hass.services.async_call( 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.assert_called_once_with("command-topic", "OPEN", 0, False)
mqtt_mock.async_publish.reset_mock() mqtt_mock.async_publish.reset_mock()
state = hass.states.get("lock.test") state = hass.states.get("lock.test")
assert state.state is STATE_OPEN assert state.state == LockState.OPEN
assert state.attributes.get(ATTR_ASSUMED_STATE) assert state.attributes.get(ATTR_ASSUMED_STATE)
@ -644,7 +638,7 @@ async def test_sending_mqtt_commands_pessimistic(
await hass.async_block_till_done() await hass.async_block_till_done()
state = hass.states.get("lock.test") state = hass.states.get("lock.test")
assert state.state is STATE_LOCKED assert state.state == LockState.LOCKED
await hass.services.async_call( await hass.services.async_call(
lock.DOMAIN, SERVICE_UNLOCK, {ATTR_ENTITY_ID: "lock.test"}, blocking=True 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() await hass.async_block_till_done()
state = hass.states.get("lock.test") state = hass.states.get("lock.test")
assert state.state is STATE_UNLOCKED assert state.state == LockState.UNLOCKED
await hass.services.async_call( await hass.services.async_call(
lock.DOMAIN, SERVICE_OPEN, {ATTR_ENTITY_ID: "lock.test"}, blocking=True 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() await hass.async_block_till_done()
state = hass.states.get("lock.test") state = hass.states.get("lock.test")
assert state.state is STATE_UNLOCKED assert state.state == LockState.UNLOCKED
# send lock command to lock # send lock command to lock
await hass.services.async_call( await hass.services.async_call(
@ -688,21 +682,21 @@ async def test_sending_mqtt_commands_pessimistic(
await hass.async_block_till_done() await hass.async_block_till_done()
state = hass.states.get("lock.test") state = hass.states.get("lock.test")
assert state.state is STATE_LOCKING assert state.state == LockState.LOCKING
# receive jammed state from lock # receive jammed state from lock
async_fire_mqtt_message(hass, "state-topic", "JAMMED") async_fire_mqtt_message(hass, "state-topic", "JAMMED")
await hass.async_block_till_done() await hass.async_block_till_done()
state = hass.states.get("lock.test") state = hass.states.get("lock.test")
assert state.state is STATE_JAMMED assert state.state == LockState.JAMMED
# receive solved state from lock # receive solved state from lock
async_fire_mqtt_message(hass, "state-topic", "LOCKED") async_fire_mqtt_message(hass, "state-topic", "LOCKED")
await hass.async_block_till_done() await hass.async_block_till_done()
state = hass.states.get("lock.test") state = hass.states.get("lock.test")
assert state.state is STATE_LOCKED assert state.state == LockState.LOCKED
@pytest.mark.parametrize("hass_config", [DEFAULT_CONFIG]) @pytest.mark.parametrize("hass_config", [DEFAULT_CONFIG])

7
tests/components/prometheus/test_init.py
View File

@ -50,6 +50,7 @@ from homeassistant.components.fan import (
DIRECTION_REVERSE, DIRECTION_REVERSE,
) )
from homeassistant.components.humidifier import ATTR_AVAILABLE_MODES from homeassistant.components.humidifier import ATTR_AVAILABLE_MODES
from homeassistant.components.lock import LockState
from homeassistant.components.sensor import SensorDeviceClass from homeassistant.components.sensor import SensorDeviceClass
from homeassistant.const import ( from homeassistant.const import (
ATTR_BATTERY_LEVEL, ATTR_BATTERY_LEVEL,
@ -67,14 +68,12 @@ from homeassistant.const import (
STATE_CLOSED, STATE_CLOSED,
STATE_CLOSING, STATE_CLOSING,
STATE_HOME, STATE_HOME,
STATE_LOCKED,
STATE_NOT_HOME, STATE_NOT_HOME,
STATE_OFF, STATE_OFF,
STATE_ON, STATE_ON,
STATE_OPEN, STATE_OPEN,
STATE_OPENING, STATE_OPENING,
STATE_UNAVAILABLE, STATE_UNAVAILABLE,
STATE_UNLOCKED,
UnitOfEnergy, UnitOfEnergy,
UnitOfTemperature, UnitOfTemperature,
) )
@ -1571,7 +1570,7 @@ async def lock_fixture(
suggested_object_id="front_door", suggested_object_id="front_door",
original_name="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 data["lock_1"] = lock_1
lock_2 = entity_registry.async_get_or_create( lock_2 = entity_registry.async_get_or_create(
@ -1581,7 +1580,7 @@ async def lock_fixture(
suggested_object_id="kitchen_door", suggested_object_id="kitchen_door",
original_name="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 data["lock_2"] = lock_2
await hass.async_block_till_done() await hass.async_block_till_done()

11
tests/components/recorder/test_init.py
View File

@ -17,6 +17,7 @@ from sqlalchemy.exc import DatabaseError, OperationalError, SQLAlchemyError
from sqlalchemy.pool import QueuePool from sqlalchemy.pool import QueuePool
from homeassistant.components import recorder from homeassistant.components import recorder
from homeassistant.components.lock import LockState
from homeassistant.components.recorder import ( from homeassistant.components.recorder import (
CONF_AUTO_PURGE, CONF_AUTO_PURGE,
CONF_AUTO_REPACK, CONF_AUTO_REPACK,
@ -69,8 +70,6 @@ from homeassistant.const import (
EVENT_HOMEASSISTANT_STARTED, EVENT_HOMEASSISTANT_STARTED,
EVENT_HOMEASSISTANT_STOP, EVENT_HOMEASSISTANT_STOP,
MATCH_ALL, MATCH_ALL,
STATE_LOCKED,
STATE_UNLOCKED,
) )
from homeassistant.core import Context, CoreState, Event, HomeAssistant, State, callback from homeassistant.core import Context, CoreState, Event, HomeAssistant, State, callback
from homeassistant.helpers import ( from homeassistant.helpers import (
@ -834,8 +833,8 @@ async def test_saving_state_and_removing_entity(
) -> None: ) -> None:
"""Test saving the state of a removed entity.""" """Test saving the state of a removed entity."""
entity_id = "lock.mine" entity_id = "lock.mine"
hass.states.async_set(entity_id, STATE_LOCKED) hass.states.async_set(entity_id, LockState.LOCKED)
hass.states.async_set(entity_id, STATE_UNLOCKED) hass.states.async_set(entity_id, LockState.UNLOCKED)
hass.states.async_remove(entity_id) hass.states.async_remove(entity_id)
await async_wait_recording_done(hass) await async_wait_recording_done(hass)
@ -848,9 +847,9 @@ async def test_saving_state_and_removing_entity(
) )
assert len(states) == 3 assert len(states) == 3
assert states[0].entity_id == entity_id 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].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].entity_id == entity_id
assert states[2].state is None assert states[2].state is None

14
tests/components/schlage/test_lock.py
View File

@ -5,15 +5,9 @@ from unittest.mock import Mock
from freezegun.api import FrozenDateTimeFactory 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.config_entries import ConfigEntry
from homeassistant.const import ( from homeassistant.const import ATTR_ENTITY_ID, SERVICE_LOCK, SERVICE_UNLOCK
ATTR_ENTITY_ID,
SERVICE_LOCK,
SERVICE_UNLOCK,
STATE_JAMMED,
STATE_UNLOCKED,
)
from homeassistant.core import HomeAssistant from homeassistant.core import HomeAssistant
from tests.common import async_fire_time_changed from tests.common import async_fire_time_changed
@ -29,7 +23,7 @@ async def test_lock_attributes(
"""Test lock attributes.""" """Test lock attributes."""
lock = hass.states.get("lock.vault_door") lock = hass.states.get("lock.vault_door")
assert lock is not None assert lock is not None
assert lock.state == STATE_UNLOCKED assert lock.state == LockState.UNLOCKED
assert lock.attributes["changed_by"] == "thumbturn" assert lock.attributes["changed_by"] == "thumbturn"
mock_lock.is_locked = False mock_lock.is_locked = False
@ -40,7 +34,7 @@ async def test_lock_attributes(
await hass.async_block_till_done(wait_background_tasks=True) await hass.async_block_till_done(wait_background_tasks=True)
lock = hass.states.get("lock.vault_door") lock = hass.states.get("lock.vault_door")
assert lock is not None assert lock is not None
assert lock.state == STATE_JAMMED assert lock.state == LockState.JAMMED
async def test_lock_services( async def test_lock_services(

15
tests/components/switch_as_x/__init__.py
View File

@ -1,14 +1,7 @@
"""The tests for Switch as X platforms.""" """The tests for Switch as X platforms."""
from homeassistant.const import ( from homeassistant.components.lock import LockState
STATE_CLOSED, from homeassistant.const import STATE_CLOSED, STATE_OFF, STATE_ON, STATE_OPEN, Platform
STATE_LOCKED,
STATE_OFF,
STATE_ON,
STATE_OPEN,
STATE_UNLOCKED,
Platform,
)
PLATFORMS_TO_TEST = ( PLATFORMS_TO_TEST = (
Platform.COVER, Platform.COVER,
@ -24,7 +17,7 @@ STATE_MAP = {
Platform.COVER: {STATE_ON: STATE_OPEN, STATE_OFF: STATE_CLOSED}, Platform.COVER: {STATE_ON: STATE_OPEN, STATE_OFF: STATE_CLOSED},
Platform.FAN: {STATE_ON: STATE_ON, STATE_OFF: STATE_OFF}, Platform.FAN: {STATE_ON: STATE_ON, STATE_OFF: STATE_OFF},
Platform.LIGHT: {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.SIREN: {STATE_ON: STATE_ON, STATE_OFF: STATE_OFF},
Platform.VALVE: {STATE_ON: STATE_OPEN, STATE_OFF: STATE_CLOSED}, 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.COVER: {STATE_ON: STATE_CLOSED, STATE_OFF: STATE_OPEN},
Platform.FAN: {STATE_ON: STATE_ON, STATE_OFF: STATE_OFF}, Platform.FAN: {STATE_ON: STATE_ON, STATE_OFF: STATE_OFF},
Platform.LIGHT: {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.SIREN: {STATE_ON: STATE_ON, STATE_OFF: STATE_OFF},
Platform.VALVE: {STATE_ON: STATE_CLOSED, STATE_OFF: STATE_OPEN}, Platform.VALVE: {STATE_ON: STATE_CLOSED, STATE_OFF: STATE_OPEN},
}, },

5
tests/components/switch_as_x/test_init.py
View File

@ -7,6 +7,7 @@ from unittest.mock import patch
import pytest import pytest
from homeassistant.components.homeassistant import exposed_entities 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.config_flow import SwitchAsXConfigFlowHandler
from homeassistant.components.switch_as_x.const import ( from homeassistant.components.switch_as_x.const import (
CONF_INVERT, CONF_INVERT,
@ -17,11 +18,9 @@ from homeassistant.config_entries import ConfigEntryState
from homeassistant.const import ( from homeassistant.const import (
CONF_ENTITY_ID, CONF_ENTITY_ID,
STATE_CLOSED, STATE_CLOSED,
STATE_LOCKED,
STATE_OFF, STATE_OFF,
STATE_ON, STATE_ON,
STATE_OPEN, STATE_OPEN,
STATE_UNLOCKED,
EntityCategory, EntityCategory,
Platform, Platform,
) )
@ -74,7 +73,7 @@ async def test_config_entry_unregistered_uuid(
(Platform.COVER, STATE_OPEN, STATE_CLOSED), (Platform.COVER, STATE_OPEN, STATE_CLOSED),
(Platform.FAN, STATE_ON, STATE_OFF), (Platform.FAN, STATE_ON, STATE_OFF),
(Platform.LIGHT, 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.SIREN, STATE_ON, STATE_OFF),
(Platform.VALVE, STATE_OPEN, STATE_CLOSED), (Platform.VALVE, STATE_OPEN, STATE_CLOSED),
], ],

28
tests/components/switch_as_x/test_lock.py
View File

@ -1,6 +1,6 @@
"""Tests for the Switch as X Lock platform.""" """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 import DOMAIN as SWITCH_DOMAIN
from homeassistant.components.switch_as_x.config_flow import SwitchAsXConfigFlowHandler from homeassistant.components.switch_as_x.config_flow import SwitchAsXConfigFlowHandler
from homeassistant.components.switch_as_x.const import ( from homeassistant.components.switch_as_x.const import (
@ -15,10 +15,8 @@ from homeassistant.const import (
SERVICE_TURN_OFF, SERVICE_TURN_OFF,
SERVICE_TURN_ON, SERVICE_TURN_ON,
SERVICE_UNLOCK, SERVICE_UNLOCK,
STATE_LOCKED,
STATE_OFF, STATE_OFF,
STATE_ON, STATE_ON,
STATE_UNLOCKED,
Platform, Platform,
) )
from homeassistant.core import HomeAssistant 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) assert await hass.config_entries.async_setup(config_entry.entry_id)
await hass.async_block_till_done() 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( await hass.services.async_call(
LOCK_DOMAIN, 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("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( await hass.services.async_call(
LOCK_DOMAIN, 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("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( await hass.services.async_call(
SWITCH_DOMAIN, 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("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( await hass.services.async_call(
SWITCH_DOMAIN, 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("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( await hass.services.async_call(
SWITCH_DOMAIN, 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("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: 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) assert await hass.config_entries.async_setup(config_entry.entry_id)
await hass.async_block_till_done() 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( await hass.services.async_call(
LOCK_DOMAIN, 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("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( await hass.services.async_call(
LOCK_DOMAIN, 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("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( await hass.services.async_call(
SWITCH_DOMAIN, 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("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( await hass.services.async_call(
SWITCH_DOMAIN, 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("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( await hass.services.async_call(
SWITCH_DOMAIN, 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("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

15
tests/components/tedee/test_lock.py
View File

@ -19,10 +19,7 @@ from homeassistant.components.lock import (
SERVICE_LOCK, SERVICE_LOCK,
SERVICE_OPEN, SERVICE_OPEN,
SERVICE_UNLOCK, SERVICE_UNLOCK,
STATE_LOCKED, LockState,
STATE_LOCKING,
STATE_UNLOCKED,
STATE_UNLOCKING,
) )
from homeassistant.components.webhook import async_generate_url from homeassistant.components.webhook import async_generate_url
from homeassistant.const import ATTR_ENTITY_ID, STATE_UNAVAILABLE, STATE_UNKNOWN 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) mock_tedee.lock.assert_called_once_with(12345)
state = hass.states.get("lock.lock_1a2b") state = hass.states.get("lock.lock_1a2b")
assert state assert state
assert state.state == STATE_LOCKING assert state.state == LockState.LOCKING
await hass.services.async_call( await hass.services.async_call(
LOCK_DOMAIN, LOCK_DOMAIN,
@ -90,7 +87,7 @@ async def test_lock(
mock_tedee.unlock.assert_called_once_with(12345) mock_tedee.unlock.assert_called_once_with(12345)
state = hass.states.get("lock.lock_1a2b") state = hass.states.get("lock.lock_1a2b")
assert state assert state
assert state.state == STATE_UNLOCKING assert state.state == LockState.UNLOCKING
await hass.services.async_call( await hass.services.async_call(
LOCK_DOMAIN, LOCK_DOMAIN,
@ -105,7 +102,7 @@ async def test_lock(
mock_tedee.open.assert_called_once_with(12345) mock_tedee.open.assert_called_once_with(12345)
state = hass.states.get("lock.lock_1a2b") state = hass.states.get("lock.lock_1a2b")
assert state assert state
assert state.state == STATE_UNLOCKING assert state.state == LockState.UNLOCKING
async def test_lock_without_pullspring( async def test_lock_without_pullspring(
@ -279,7 +276,7 @@ async def test_new_lock(
@pytest.mark.parametrize( @pytest.mark.parametrize(
("lib_state", "expected_state"), ("lib_state", "expected_state"),
[ [
(TedeeLockState.LOCKED, STATE_LOCKED), (TedeeLockState.LOCKED, LockState.LOCKED),
(TedeeLockState.HALF_OPEN, STATE_UNKNOWN), (TedeeLockState.HALF_OPEN, STATE_UNKNOWN),
(TedeeLockState.UNKNOWN, STATE_UNKNOWN), (TedeeLockState.UNKNOWN, STATE_UNKNOWN),
(TedeeLockState.UNCALIBRATED, STATE_UNAVAILABLE), (TedeeLockState.UNCALIBRATED, STATE_UNAVAILABLE),
@ -296,7 +293,7 @@ async def test_webhook_update(
state = hass.states.get("lock.lock_1a2b") state = hass.states.get("lock.lock_1a2b")
assert state assert state
assert state.state == STATE_UNLOCKED assert state.state == LockState.UNLOCKED
webhook_data = {"dummystate": lib_state.value} webhook_data = {"dummystate": lib_state.value}
# is updated in the lib, so mock and assert below # is updated in the lib, so mock and assert below

29
tests/components/template/test_lock.py
View File

@ -4,6 +4,7 @@ import pytest
from homeassistant import setup from homeassistant import setup
from homeassistant.components import lock from homeassistant.components import lock
from homeassistant.components.lock import LockState
from homeassistant.const import ( from homeassistant.const import (
ATTR_CODE, ATTR_CODE,
ATTR_ENTITY_ID, ATTR_ENTITY_ID,
@ -71,13 +72,13 @@ async def test_template_state(hass: HomeAssistant, start_ha) -> None:
await hass.async_block_till_done() await hass.async_block_till_done()
state = hass.states.get("lock.test_template_lock") 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) hass.states.async_set("switch.test_state", STATE_OFF)
await hass.async_block_till_done() await hass.async_block_till_done()
state = hass.states.get("lock.test_template_lock") 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)]) @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: async def test_template_state_boolean_on(hass: HomeAssistant, start_ha) -> None:
"""Test the setting of the state with boolean on.""" """Test the setting of the state with boolean on."""
state = hass.states.get("lock.template_lock") 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)]) @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: async def test_template_state_boolean_off(hass: HomeAssistant, start_ha) -> None:
"""Test the setting of the state with off.""" """Test the setting of the state with off."""
state = hass.states.get("lock.template_lock") 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)]) @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: async def test_template_static(hass: HomeAssistant, start_ha) -> None:
"""Test that we allow static templates.""" """Test that we allow static templates."""
state = hass.states.get("lock.template_lock") 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() await hass.async_block_till_done()
state = hass.states.get("lock.template_lock") 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)]) @pytest.mark.parametrize(("count", "domain"), [(1, lock.DOMAIN)])
@ -229,7 +230,7 @@ async def test_lock_action(
await hass.async_block_till_done() await hass.async_block_till_done()
state = hass.states.get("lock.template_lock") state = hass.states.get("lock.template_lock")
assert state.state == lock.STATE_UNLOCKED assert state.state == LockState.UNLOCKED
await hass.services.async_call( await hass.services.async_call(
lock.DOMAIN, lock.DOMAIN,
@ -264,7 +265,7 @@ async def test_unlock_action(
await hass.async_block_till_done() await hass.async_block_till_done()
state = hass.states.get("lock.template_lock") state = hass.states.get("lock.template_lock")
assert state.state == lock.STATE_LOCKED assert state.state == LockState.LOCKED
await hass.services.async_call( await hass.services.async_call(
lock.DOMAIN, lock.DOMAIN,
@ -300,7 +301,7 @@ async def test_lock_action_with_code(
await hass.async_block_till_done() await hass.async_block_till_done()
state = hass.states.get("lock.template_lock") state = hass.states.get("lock.template_lock")
assert state.state == lock.STATE_UNLOCKED assert state.state == LockState.UNLOCKED
await hass.services.async_call( await hass.services.async_call(
lock.DOMAIN, lock.DOMAIN,
@ -337,7 +338,7 @@ async def test_unlock_action_with_code(
await hass.async_block_till_done() await hass.async_block_till_done()
state = hass.states.get("lock.template_lock") state = hass.states.get("lock.template_lock")
assert state.state == lock.STATE_LOCKED assert state.state == LockState.LOCKED
await hass.services.async_call( await hass.services.async_call(
lock.DOMAIN, lock.DOMAIN,
@ -446,7 +447,7 @@ async def test_actions_with_none_as_codeformat_ignores_code(
await hass.async_block_till_done() await hass.async_block_till_done()
state = hass.states.get("lock.template_lock") state = hass.states.get("lock.template_lock")
assert state.state == lock.STATE_UNLOCKED assert state.state == LockState.UNLOCKED
await hass.services.async_call( await hass.services.async_call(
lock.DOMAIN, lock.DOMAIN,
@ -484,7 +485,7 @@ async def test_actions_with_invalid_regexp_as_codeformat_never_execute(
await hass.async_block_till_done() await hass.async_block_till_done()
state = hass.states.get("lock.template_lock") state = hass.states.get("lock.template_lock")
assert state.state == lock.STATE_UNLOCKED assert state.state == LockState.UNLOCKED
await hass.services.async_call( await hass.services.async_call(
lock.DOMAIN, lock.DOMAIN,
@ -519,7 +520,7 @@ async def test_actions_with_invalid_regexp_as_codeformat_never_execute(
], ],
) )
@pytest.mark.parametrize( @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: async def test_lock_state(hass: HomeAssistant, test_state, start_ha) -> None:
"""Test value template.""" """Test value template."""

15
tests/components/tesla_fleet/test_lock.py
View File

@ -10,14 +10,9 @@ from homeassistant.components.lock import (
DOMAIN as LOCK_DOMAIN, DOMAIN as LOCK_DOMAIN,
SERVICE_LOCK, SERVICE_LOCK,
SERVICE_UNLOCK, SERVICE_UNLOCK,
LockState,
) )
from homeassistant.const import ( from homeassistant.const import ATTR_ENTITY_ID, STATE_UNKNOWN, Platform
ATTR_ENTITY_ID,
STATE_LOCKED,
STATE_UNKNOWN,
STATE_UNLOCKED,
Platform,
)
from homeassistant.core import HomeAssistant from homeassistant.core import HomeAssistant
from homeassistant.exceptions import ServiceValidationError from homeassistant.exceptions import ServiceValidationError
from homeassistant.helpers import entity_registry as er from homeassistant.helpers import entity_registry as er
@ -74,7 +69,7 @@ async def test_lock_services(
blocking=True, blocking=True,
) )
state = hass.states.get(entity_id) state = hass.states.get(entity_id)
assert state.state == STATE_LOCKED assert state.state == LockState.LOCKED
call.assert_called_once() call.assert_called_once()
with patch( with patch(
@ -88,7 +83,7 @@ async def test_lock_services(
blocking=True, blocking=True,
) )
state = hass.states.get(entity_id) state = hass.states.get(entity_id)
assert state.state == STATE_UNLOCKED assert state.state == LockState.UNLOCKED
call.assert_called_once() call.assert_called_once()
entity_id = "lock.test_charge_cable_lock" entity_id = "lock.test_charge_cable_lock"
@ -112,5 +107,5 @@ async def test_lock_services(
blocking=True, blocking=True,
) )
state = hass.states.get(entity_id) state = hass.states.get(entity_id)
assert state.state == STATE_UNLOCKED assert state.state == LockState.UNLOCKED
call.assert_called_once() call.assert_called_once()

15
tests/components/teslemetry/test_lock.py
View File

@ -10,14 +10,9 @@ from homeassistant.components.lock import (
DOMAIN as LOCK_DOMAIN, DOMAIN as LOCK_DOMAIN,
SERVICE_LOCK, SERVICE_LOCK,
SERVICE_UNLOCK, SERVICE_UNLOCK,
LockState,
) )
from homeassistant.const import ( from homeassistant.const import ATTR_ENTITY_ID, STATE_UNKNOWN, Platform
ATTR_ENTITY_ID,
STATE_LOCKED,
STATE_UNKNOWN,
STATE_UNLOCKED,
Platform,
)
from homeassistant.core import HomeAssistant from homeassistant.core import HomeAssistant
from homeassistant.exceptions import ServiceValidationError from homeassistant.exceptions import ServiceValidationError
from homeassistant.helpers import entity_registry as er from homeassistant.helpers import entity_registry as er
@ -69,7 +64,7 @@ async def test_lock_services(
blocking=True, blocking=True,
) )
state = hass.states.get(entity_id) state = hass.states.get(entity_id)
assert state.state == STATE_LOCKED assert state.state == LockState.LOCKED
call.assert_called_once() call.assert_called_once()
with patch( with patch(
@ -83,7 +78,7 @@ async def test_lock_services(
blocking=True, blocking=True,
) )
state = hass.states.get(entity_id) state = hass.states.get(entity_id)
assert state.state == STATE_UNLOCKED assert state.state == LockState.UNLOCKED
call.assert_called_once() call.assert_called_once()
entity_id = "lock.test_charge_cable_lock" entity_id = "lock.test_charge_cable_lock"
@ -107,5 +102,5 @@ async def test_lock_services(
blocking=True, blocking=True,
) )
state = hass.states.get(entity_id) state = hass.states.get(entity_id)
assert state.state == STATE_UNLOCKED assert state.state == LockState.UNLOCKED
call.assert_called_once() call.assert_called_once()

13
tests/components/tessie/test_lock.py
View File

@ -10,8 +10,9 @@ from homeassistant.components.lock import (
DOMAIN as LOCK_DOMAIN, DOMAIN as LOCK_DOMAIN,
SERVICE_LOCK, SERVICE_LOCK,
SERVICE_UNLOCK, 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.core import HomeAssistant
from homeassistant.exceptions import ServiceValidationError from homeassistant.exceptions import ServiceValidationError
from homeassistant.helpers import entity_registry as er, issue_registry as ir from homeassistant.helpers import entity_registry as er, issue_registry as ir
@ -49,7 +50,7 @@ async def test_locks(
blocking=True, blocking=True,
) )
mock_run.assert_called_once() 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: with patch("homeassistant.components.tessie.lock.unlock") as mock_run:
await hass.services.async_call( await hass.services.async_call(
@ -59,7 +60,7 @@ async def test_locks(
blocking=True, blocking=True,
) )
mock_run.assert_called_once() 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 # Test charge cable lock set value functions
entity_id = "lock.test_charge_cable_lock" entity_id = "lock.test_charge_cable_lock"
@ -80,7 +81,7 @@ async def test_locks(
{ATTR_ENTITY_ID: [entity_id]}, {ATTR_ENTITY_ID: [entity_id]},
blocking=True, 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() mock_run.assert_called_once()
@ -119,7 +120,7 @@ async def test_speed_limit_lock(
{ATTR_ENTITY_ID: [entity.entity_id], ATTR_CODE: "1234"}, {ATTR_ENTITY_ID: [entity.entity_id], ATTR_CODE: "1234"},
blocking=True, 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() mock_enable_speed_limit.assert_called_once()
# Assert issue has been raised in the issue register # Assert issue has been raised in the issue register
assert issue_registry.async_get_issue(DOMAIN, "deprecated_speed_limit_locked") 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"}, {ATTR_ENTITY_ID: [entity.entity_id], ATTR_CODE: "1234"},
blocking=True, 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() mock_disable_speed_limit.assert_called_once()
assert issue_registry.async_get_issue(DOMAIN, "deprecated_speed_limit_unlocked") assert issue_registry.async_get_issue(DOMAIN, "deprecated_speed_limit_unlocked")

16
tests/components/unifiprotect/test_lock.py
View File

@ -6,16 +6,12 @@ from unittest.mock import AsyncMock, Mock
from uiprotect.data import Doorlock, LockStatusType from uiprotect.data import Doorlock, LockStatusType
from homeassistant.components.lock import LockState
from homeassistant.components.unifiprotect.const import DEFAULT_ATTRIBUTION from homeassistant.components.unifiprotect.const import DEFAULT_ATTRIBUTION
from homeassistant.const import ( from homeassistant.const import (
ATTR_ATTRIBUTION, ATTR_ATTRIBUTION,
ATTR_ENTITY_ID, ATTR_ENTITY_ID,
STATE_JAMMED,
STATE_LOCKED,
STATE_LOCKING,
STATE_UNAVAILABLE, STATE_UNAVAILABLE,
STATE_UNLOCKED,
STATE_UNLOCKING,
Platform, Platform,
) )
from homeassistant.core import HomeAssistant from homeassistant.core import HomeAssistant
@ -64,7 +60,7 @@ async def test_lock_setup(
state = hass.states.get(entity_id) state = hass.states.get(entity_id)
assert state assert state
assert state.state == STATE_UNLOCKED assert state.state == LockState.UNLOCKED
assert state.attributes[ATTR_ATTRIBUTION] == DEFAULT_ATTRIBUTION assert state.attributes[ATTR_ATTRIBUTION] == DEFAULT_ATTRIBUTION
@ -92,7 +88,7 @@ async def test_lock_locked(
state = hass.states.get("lock.test_lock_lock") state = hass.states.get("lock.test_lock_lock")
assert state assert state
assert state.state == STATE_LOCKED assert state.state == LockState.LOCKED
async def test_lock_unlocking( async def test_lock_unlocking(
@ -119,7 +115,7 @@ async def test_lock_unlocking(
state = hass.states.get("lock.test_lock_lock") state = hass.states.get("lock.test_lock_lock")
assert state assert state
assert state.state == STATE_UNLOCKING assert state.state == LockState.UNLOCKING
async def test_lock_locking( async def test_lock_locking(
@ -146,7 +142,7 @@ async def test_lock_locking(
state = hass.states.get("lock.test_lock_lock") state = hass.states.get("lock.test_lock_lock")
assert state assert state
assert state.state == STATE_LOCKING assert state.state == LockState.LOCKING
async def test_lock_jammed( async def test_lock_jammed(
@ -173,7 +169,7 @@ async def test_lock_jammed(
state = hass.states.get("lock.test_lock_lock") state = hass.states.get("lock.test_lock_lock")
assert state assert state
assert state.state == STATE_JAMMED assert state.state == LockState.JAMMED
async def test_lock_unavailable( async def test_lock_unavailable(

8
tests/components/vera/test_lock.py
View File

@ -4,7 +4,7 @@ from unittest.mock import MagicMock
import pyvera as pv import pyvera as pv
from homeassistant.const import STATE_LOCKED, STATE_UNLOCKED from homeassistant.components.lock import LockState
from homeassistant.core import HomeAssistant from homeassistant.core import HomeAssistant
from .common import ComponentFactory, new_simple_controller_config 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 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( await hass.services.async_call(
"lock", "lock",
@ -41,7 +41,7 @@ async def test_lock(
vera_device.is_locked.return_value = True vera_device.is_locked.return_value = True
update_callback(vera_device) update_callback(vera_device)
await hass.async_block_till_done() 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( await hass.services.async_call(
"lock", "lock",
@ -53,4 +53,4 @@ async def test_lock(
vera_device.is_locked.return_value = False vera_device.is_locked.return_value = False
update_callback(vera_device) update_callback(vera_device)
await hass.async_block_till_done() await hass.async_block_till_done()
assert hass.states.get(entity_id).state == STATE_UNLOCKED assert hass.states.get(entity_id).state == LockState.UNLOCKED

5
tests/components/yale/test_init.py
View File

@ -6,7 +6,7 @@ from aiohttp import ClientResponseError
import pytest import pytest
from yalexs.exceptions import InvalidAuth, YaleApiError 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.components.yale.const import DOMAIN
from homeassistant.config_entries import ConfigEntryState from homeassistant.config_entries import ConfigEntryState
from homeassistant.const import ( from homeassistant.const import (
@ -14,7 +14,6 @@ from homeassistant.const import (
SERVICE_LOCK, SERVICE_LOCK,
SERVICE_OPEN, SERVICE_OPEN,
SERVICE_UNLOCK, SERVICE_UNLOCK,
STATE_LOCKED,
STATE_ON, STATE_ON,
) )
from homeassistant.core import HomeAssistant 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 = hass.states.get(
"lock.a6697750d607098bae8d6baa11ef8063_name" "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: async def test_lock_has_doorsense(hass: HomeAssistant) -> None:

63
tests/components/yale/test_lock.py
View File

@ -8,21 +8,14 @@ import pytest
from syrupy import SnapshotAssertion from syrupy import SnapshotAssertion
from yalexs.manager.activity import INITIAL_LOCK_RESYNC_TIME from yalexs.manager.activity import INITIAL_LOCK_RESYNC_TIME
from homeassistant.components.lock import ( from homeassistant.components.lock import DOMAIN as LOCK_DOMAIN, LockState
DOMAIN as LOCK_DOMAIN,
STATE_JAMMED,
STATE_LOCKING,
STATE_UNLOCKING,
)
from homeassistant.const import ( from homeassistant.const import (
ATTR_ENTITY_ID, ATTR_ENTITY_ID,
SERVICE_LOCK, SERVICE_LOCK,
SERVICE_OPEN, SERVICE_OPEN,
SERVICE_UNLOCK, SERVICE_UNLOCK,
STATE_LOCKED,
STATE_UNAVAILABLE, STATE_UNAVAILABLE,
STATE_UNKNOWN, STATE_UNKNOWN,
STATE_UNLOCKED,
) )
from homeassistant.core import HomeAssistant from homeassistant.core import HomeAssistant
from homeassistant.exceptions import HomeAssistantError 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) await _create_yale_with_devices(hass, [lock_one], activities=activities)
lock_state = hass.states.get("lock.online_with_doorsense_name") 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" 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") activities = await _mock_activities_from_fixture(hass, "get_activity.locking.json")
await _create_yale_with_devices(hass, [lock_one], activities=activities) 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: 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") 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: 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") activities = await _mock_activities_from_fixture(hass, "get_activity.jammed.json")
await _create_yale_with_devices(hass, [lock_one], activities=activities) 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( 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") 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["battery_level"] == 92
assert lock_state.attributes["friendly_name"] == "online_with_doorsense Name" 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) await hass.services.async_call(LOCK_DOMAIN, SERVICE_UNLOCK, data, blocking=True)
lock_state = hass.states.get("lock.online_with_doorsense_name") 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["battery_level"] == 92
assert lock_state.attributes["friendly_name"] == "online_with_doorsense Name" 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) await hass.services.async_call(LOCK_DOMAIN, SERVICE_LOCK, data, blocking=True)
lock_state = hass.states.get("lock.online_with_doorsense_name") 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 # No activity means it will be unavailable until the activity feed has data
assert entity_registry.async_get("sensor.online_with_doorsense_name_operator") 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) lock_with_unlatch = await _mock_lock_with_unlatch(hass)
await _create_yale_with_devices(hass, [lock_with_unlatch]) 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"} data = {ATTR_ENTITY_ID: "lock.online_with_unlatch_name"}
await hass.services.async_call(LOCK_DOMAIN, SERVICE_OPEN, data, blocking=True) 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( 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 = await _create_yale_with_devices(hass, [lock_with_unlatch])
socketio.connected = True 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"} data = {ATTR_ENTITY_ID: "lock.online_with_unlatch_name"}
await hass.services.async_call(LOCK_DOMAIN, SERVICE_OPEN, data, blocking=True) 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()
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() await hass.async_block_till_done()
@ -194,7 +187,7 @@ async def test_one_lock_operation_socketio_connected(
socketio.connected = True socketio.connected = True
lock_state = hass.states.get("lock.online_with_doorsense_name") 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["battery_level"] == 92
assert lock_state.attributes["friendly_name"] == "online_with_doorsense Name" 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() await hass.async_block_till_done()
lock_state = states.get("lock.online_with_doorsense_name") 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["battery_level"] == 92
assert lock_state.attributes["friendly_name"] == "online_with_doorsense Name" 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()
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 # No activity means it will be unavailable until the activity feed has data
assert entity_registry.async_get("sensor.online_with_doorsense_name_operator") 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() 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: async def test_lock_jammed(hass: HomeAssistant) -> None:
@ -271,14 +264,14 @@ async def test_lock_jammed(hass: HomeAssistant) -> None:
states = hass.states states = hass.states
lock_state = states.get("lock.online_with_doorsense_name") 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["battery_level"] == 92
assert lock_state.attributes["friendly_name"] == "online_with_doorsense Name" assert lock_state.attributes["friendly_name"] == "online_with_doorsense Name"
data = {ATTR_ENTITY_ID: "lock.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) 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( 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") 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["battery_level"] == 92
assert lock_state.attributes["friendly_name"] == "online_with_doorsense Name" 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) await _create_yale_with_devices(hass, [lock_one], activities=activities)
states = hass.states 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: 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 socketio.connected = True
states = hass.states 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 = list(socketio._listeners)[0]
listener( 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()
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( listener(
lock_one.device_id, 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()
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)) async_fire_time_changed(hass, dt_util.utcnow() + datetime.timedelta(seconds=30))
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
socketio.connected = True socketio.connected = True
async_fire_time_changed(hass, dt_util.utcnow() + datetime.timedelta(seconds=30)) async_fire_time_changed(hass, dt_util.utcnow() + datetime.timedelta(seconds=30))
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
# Ensure socketio status is always preserved # Ensure socketio status is always preserved
async_fire_time_changed(hass, dt_util.utcnow() + datetime.timedelta(hours=2)) async_fire_time_changed(hass, dt_util.utcnow() + datetime.timedelta(hours=2))
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
listener( listener(
lock_one.device_id, 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()
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)) async_fire_time_changed(hass, dt_util.utcnow() + datetime.timedelta(hours=4))
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
await hass.config_entries.async_unload(config_entry.entry_id) await hass.config_entries.async_unload(config_entry.entry_id)
await hass.async_block_till_done() await hass.async_block_till_done()

10
tests/components/zha/test_lock.py
View File

@ -8,14 +8,14 @@ from zigpy.zcl import Cluster
from zigpy.zcl.clusters import closures, general from zigpy.zcl.clusters import closures, general
import zigpy.zcl.foundation as zcl_f 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 ( from homeassistant.components.zha.helpers import (
ZHADeviceProxy, ZHADeviceProxy,
ZHAGatewayProxy, ZHAGatewayProxy,
get_zha_gateway, get_zha_gateway,
get_zha_gateway_proxy, get_zha_gateway_proxy,
) )
from homeassistant.const import STATE_LOCKED, STATE_UNLOCKED, Platform from homeassistant.const import Platform
from homeassistant.core import HomeAssistant from homeassistant.core import HomeAssistant
from .common import find_entity_id, send_attributes_report 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 cluster = zigpy_device.endpoints[1].door_lock
assert entity_id is not None 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 # set state to locked
await send_attributes_report( await send_attributes_report(
@ -73,7 +73,7 @@ async def test_lock(hass: HomeAssistant, setup_zha, zigpy_device_mock) -> None:
cluster, cluster,
{closures.DoorLock.AttributeDefs.lock_state.id: closures.LockState.Locked}, {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 # set state to unlocked
await send_attributes_report( await send_attributes_report(
@ -81,7 +81,7 @@ async def test_lock(hass: HomeAssistant, setup_zha, zigpy_device_mock) -> None:
cluster, cluster,
{closures.DoorLock.AttributeDefs.lock_state.id: closures.LockState.Unlocked}, {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 # lock from HA
await async_lock(hass, cluster, entity_id) await async_lock(hass, cluster, entity_id)

13
tests/components/zwave_js/test_lock.py
View File

@ -15,6 +15,7 @@ from homeassistant.components.lock import (
DOMAIN as LOCK_DOMAIN, DOMAIN as LOCK_DOMAIN,
SERVICE_LOCK, SERVICE_LOCK,
SERVICE_UNLOCK, SERVICE_UNLOCK,
LockState,
) )
from homeassistant.components.zwave_js.const import ( from homeassistant.components.zwave_js.const import (
ATTR_LOCK_TIMEOUT, ATTR_LOCK_TIMEOUT,
@ -27,13 +28,7 @@ from homeassistant.components.zwave_js.lock import (
SERVICE_SET_LOCK_CONFIGURATION, SERVICE_SET_LOCK_CONFIGURATION,
SERVICE_SET_LOCK_USERCODE, SERVICE_SET_LOCK_USERCODE,
) )
from homeassistant.const import ( from homeassistant.const import ATTR_ENTITY_ID, STATE_UNAVAILABLE, STATE_UNKNOWN
ATTR_ENTITY_ID,
STATE_LOCKED,
STATE_UNAVAILABLE,
STATE_UNKNOWN,
STATE_UNLOCKED,
)
from homeassistant.core import HomeAssistant from homeassistant.core import HomeAssistant
from homeassistant.exceptions import HomeAssistantError from homeassistant.exceptions import HomeAssistantError
@ -52,7 +47,7 @@ async def test_door_lock(
state = hass.states.get(SCHLAGE_BE469_LOCK_ENTITY) state = hass.states.get(SCHLAGE_BE469_LOCK_ENTITY)
assert state assert state
assert state.state == STATE_UNLOCKED assert state.state == LockState.UNLOCKED
# Test locking # Test locking
await hass.services.async_call( await hass.services.async_call(
@ -97,7 +92,7 @@ async def test_door_lock(
state = hass.states.get(SCHLAGE_BE469_LOCK_ENTITY) state = hass.states.get(SCHLAGE_BE469_LOCK_ENTITY)
assert state assert state
assert state.state == STATE_LOCKED assert state.state == LockState.LOCKED
client.async_send_command.reset_mock() client.async_send_command.reset_mock()

13
tests/helpers/test_state.py
View File

@ -5,18 +5,17 @@ from unittest.mock import patch
import pytest import pytest
from homeassistant.components.lock import LockState
from homeassistant.components.sun import STATE_ABOVE_HORIZON, STATE_BELOW_HORIZON from homeassistant.components.sun import STATE_ABOVE_HORIZON, STATE_BELOW_HORIZON
from homeassistant.const import ( from homeassistant.const import (
SERVICE_TURN_OFF, SERVICE_TURN_OFF,
SERVICE_TURN_ON, SERVICE_TURN_ON,
STATE_CLOSED, STATE_CLOSED,
STATE_HOME, STATE_HOME,
STATE_LOCKED,
STATE_NOT_HOME, STATE_NOT_HOME,
STATE_OFF, STATE_OFF,
STATE_ON, STATE_ON,
STATE_OPEN, STATE_OPEN,
STATE_UNLOCKED,
) )
from homeassistant.core import HomeAssistant, State from homeassistant.core import HomeAssistant, State
from homeassistant.helpers import state from homeassistant.helpers import state
@ -143,11 +142,17 @@ async def test_as_number_states(hass: HomeAssistant) -> None:
zero_states = ( zero_states = (
STATE_OFF, STATE_OFF,
STATE_CLOSED, STATE_CLOSED,
STATE_UNLOCKED, LockState.UNLOCKED,
STATE_BELOW_HORIZON, STATE_BELOW_HORIZON,
STATE_NOT_HOME, 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: for _state in zero_states:
assert state.state_as_number(State("domain.test", _state, {})) == 0 assert state.state_as_number(State("domain.test", _state, {})) == 0
for _state in one_states: for _state in one_states:

32
tests/test_const.py
View File

@ -5,7 +5,7 @@ from enum import Enum
import pytest import pytest
from homeassistant import const from homeassistant import const
from homeassistant.components import sensor from homeassistant.components import lock, sensor
from .common import ( from .common import (
help_test_all, help_test_all,
@ -182,3 +182,33 @@ def test_deprecated_constant_name_changes(
replacement, replacement,
"2025.1", "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
)