jeans/core
jeans/core
1
0
Fork 0
mirror of https://github.com/home-assistant/core.git synced 2025-04-23 16:57:53 +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,
)
from homeassistant.components.climate import HVACMode
from homeassistant.components.lock import LockState
from homeassistant.const import (
ATTR_CODE_FORMAT,
ATTR_SUPPORTED_FEATURES,
@ -40,16 +41,12 @@ from homeassistant.const import (
STATE_ALARM_ARMED_HOME,
STATE_ALARM_ARMED_NIGHT,
STATE_IDLE,
STATE_LOCKED,
STATE_LOCKING,
STATE_OFF,
STATE_ON,
STATE_PAUSED,
STATE_PLAYING,
STATE_UNAVAILABLE,
STATE_UNKNOWN,
STATE_UNLOCKED,
STATE_UNLOCKING,
UnitOfLength,
UnitOfMass,
UnitOfTemperature,
@ -500,10 +497,10 @@ class AlexaLockController(AlexaCapability):
raise UnsupportedProperty(name)
# If its unlocking its still locked and not unlocked yet
if self.entity.state in (STATE_UNLOCKING, STATE_LOCKED):
if self.entity.state in (LockState.UNLOCKING, LockState.LOCKED):
return "LOCKED"
# If its locking its still unlocked and not locked yet
if self.entity.state in (STATE_LOCKING, STATE_UNLOCKED):
if self.entity.state in (LockState.LOCKING, LockState.UNLOCKED):
return "UNLOCKED"
return "JAMMED"

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

34
homeassistant/const.py
View File

@ -487,15 +487,39 @@ STATE_ALARM_PENDING: Final = "pending"
STATE_ALARM_ARMING: Final = "arming"
STATE_ALARM_DISARMING: Final = "disarming"
STATE_ALARM_TRIGGERED: Final = "triggered"
STATE_LOCKED: Final = "locked"
STATE_UNLOCKED: Final = "unlocked"
STATE_LOCKING: Final = "locking"
STATE_UNLOCKING: Final = "unlocking"
STATE_JAMMED: Final = "jammed"
STATE_UNAVAILABLE: Final = "unavailable"
STATE_OK: Final = "ok"
STATE_PROBLEM: Final = "problem"
# #### LOCK STATES ####
# STATE_* below are deprecated as of 2024.10
# use the LockState enum instead.
_DEPRECATED_STATE_LOCKED: Final = DeprecatedConstant(
"locked",
"LockState.LOCKED",
"2025.10",
)
_DEPRECATED_STATE_UNLOCKED: Final = DeprecatedConstant(
"unlocked",
"LockState.UNLOCKED",
"2025.10",
)
_DEPRECATED_STATE_LOCKING: Final = DeprecatedConstant(
"locking",
"LockState.LOCKING",
"2025.10",
)
_DEPRECATED_STATE_UNLOCKING: Final = DeprecatedConstant(
"unlocking",
"LockState.UNLOCKING",
"2025.10",
)
_DEPRECATED_STATE_JAMMED: Final = DeprecatedConstant(
"jammed",
"LockState.JAMMED",
"2025.10",
)
# #### STATE AND EVENT ATTRIBUTES ####
# Attribution
ATTR_ATTRIBUTION: Final = "attribution"

7
homeassistant/helpers/state.py
View File

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

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

@ -3,13 +3,12 @@
from unittest.mock import patch
from homeassistant.components.abode import ATTR_DEVICE_ID
from homeassistant.components.lock import DOMAIN as LOCK_DOMAIN
from homeassistant.components.lock import DOMAIN as LOCK_DOMAIN, LockState
from homeassistant.const import (
ATTR_ENTITY_ID,
ATTR_FRIENDLY_NAME,
SERVICE_LOCK,
SERVICE_UNLOCK,
STATE_LOCKED,
)
from homeassistant.core import HomeAssistant
from homeassistant.helpers import entity_registry as er
@ -34,7 +33,7 @@ async def test_attributes(hass: HomeAssistant) -> None:
await setup_platform(hass, LOCK_DOMAIN)
state = hass.states.get(DEVICE_ID)
assert state.state == STATE_LOCKED
assert state.state == LockState.LOCKED
assert state.attributes.get(ATTR_DEVICE_ID) == "ZW:00000004"
assert not state.attributes.get("battery_low")
assert not state.attributes.get("no_response")

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

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

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

@ -9,14 +9,13 @@ from yalexs.const import Brand
from yalexs.exceptions import AugustApiAIOHTTPError
from homeassistant.components.august.const import DOMAIN
from homeassistant.components.lock import DOMAIN as LOCK_DOMAIN
from homeassistant.components.lock import DOMAIN as LOCK_DOMAIN, LockState
from homeassistant.config_entries import ConfigEntryState
from homeassistant.const import (
ATTR_ENTITY_ID,
SERVICE_LOCK,
SERVICE_OPEN,
SERVICE_UNLOCK,
STATE_LOCKED,
STATE_ON,
)
from homeassistant.core import HomeAssistant
@ -192,7 +191,7 @@ async def test_inoperative_locks_are_filtered_out(hass: HomeAssistant) -> None:
lock_a6697750d607098bae8d6baa11ef8063_name = hass.states.get(
"lock.a6697750d607098bae8d6baa11ef8063_name"
)
assert lock_a6697750d607098bae8d6baa11ef8063_name.state == STATE_LOCKED
assert lock_a6697750d607098bae8d6baa11ef8063_name.state == LockState.LOCKED
async def test_lock_has_doorsense(hass: HomeAssistant) -> None:

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.pubnub_async import AugustPubNub
from homeassistant.components.lock import (
DOMAIN as LOCK_DOMAIN,
STATE_JAMMED,
STATE_LOCKING,
STATE_UNLOCKING,
)
from homeassistant.components.lock import DOMAIN as LOCK_DOMAIN, LockState
from homeassistant.const import (
ATTR_ENTITY_ID,
SERVICE_LOCK,
SERVICE_OPEN,
SERVICE_UNLOCK,
STATE_LOCKED,
STATE_UNAVAILABLE,
STATE_UNKNOWN,
STATE_UNLOCKED,
)
from homeassistant.core import HomeAssistant
from homeassistant.exceptions import HomeAssistantError
@ -65,7 +58,7 @@ async def test_lock_changed_by(hass: HomeAssistant) -> None:
lock_state = hass.states.get("lock.online_with_doorsense_name")
assert lock_state.state == STATE_LOCKED
assert lock_state.state == LockState.LOCKED
assert lock_state.attributes["changed_by"] == "Your favorite elven princess"
@ -76,7 +69,7 @@ async def test_state_locking(hass: HomeAssistant) -> None:
activities = await _mock_activities_from_fixture(hass, "get_activity.locking.json")
await _create_august_with_devices(hass, [lock_one], activities=activities)
assert hass.states.get("lock.online_with_doorsense_name").state == STATE_LOCKING
assert hass.states.get("lock.online_with_doorsense_name").state == LockState.LOCKING
async def test_state_unlocking(hass: HomeAssistant) -> None:
@ -88,7 +81,9 @@ async def test_state_unlocking(hass: HomeAssistant) -> None:
)
await _create_august_with_devices(hass, [lock_one], activities=activities)
assert hass.states.get("lock.online_with_doorsense_name").state == STATE_UNLOCKING
assert (
hass.states.get("lock.online_with_doorsense_name").state == LockState.UNLOCKING
)
async def test_state_jammed(hass: HomeAssistant) -> None:
@ -98,7 +93,7 @@ async def test_state_jammed(hass: HomeAssistant) -> None:
activities = await _mock_activities_from_fixture(hass, "get_activity.jammed.json")
await _create_august_with_devices(hass, [lock_one], activities=activities)
assert hass.states.get("lock.online_with_doorsense_name").state == STATE_JAMMED
assert hass.states.get("lock.online_with_doorsense_name").state == LockState.JAMMED
async def test_one_lock_operation(
@ -111,7 +106,7 @@ async def test_one_lock_operation(
lock_state = states.get("lock.online_with_doorsense_name")
assert lock_state.state == STATE_LOCKED
assert lock_state.state == LockState.LOCKED
assert lock_state.attributes["battery_level"] == 92
assert lock_state.attributes["friendly_name"] == "online_with_doorsense Name"
@ -120,14 +115,14 @@ async def test_one_lock_operation(
await hass.services.async_call(LOCK_DOMAIN, SERVICE_UNLOCK, data, blocking=True)
lock_state = states.get("lock.online_with_doorsense_name")
assert lock_state.state == STATE_UNLOCKED
assert lock_state.state == LockState.UNLOCKED
assert lock_state.attributes["battery_level"] == 92
assert lock_state.attributes["friendly_name"] == "online_with_doorsense Name"
await hass.services.async_call(LOCK_DOMAIN, SERVICE_LOCK, data, blocking=True)
assert states.get("lock.online_with_doorsense_name").state == STATE_LOCKED
assert states.get("lock.online_with_doorsense_name").state == LockState.LOCKED
# No activity means it will be unavailable until the activity feed has data
lock_operator_sensor = entity_registry.async_get(
@ -145,13 +140,13 @@ async def test_open_lock_operation(hass: HomeAssistant) -> None:
await _create_august_with_devices(hass, [lock_with_unlatch])
lock_online_with_unlatch_name = hass.states.get("lock.online_with_unlatch_name")
assert lock_online_with_unlatch_name.state == STATE_LOCKED
assert lock_online_with_unlatch_name.state == LockState.LOCKED
data = {ATTR_ENTITY_ID: "lock.online_with_unlatch_name"}
await hass.services.async_call(LOCK_DOMAIN, SERVICE_OPEN, data, blocking=True)
lock_online_with_unlatch_name = hass.states.get("lock.online_with_unlatch_name")
assert lock_online_with_unlatch_name.state == STATE_UNLOCKED
assert lock_online_with_unlatch_name.state == LockState.UNLOCKED
async def test_open_lock_operation_pubnub_connected(
@ -167,7 +162,7 @@ async def test_open_lock_operation_pubnub_connected(
await _create_august_with_devices(hass, [lock_with_unlatch], pubnub=pubnub)
pubnub.connected = True
assert hass.states.get("lock.online_with_unlatch_name").state == STATE_LOCKED
assert hass.states.get("lock.online_with_unlatch_name").state == LockState.LOCKED
data = {ATTR_ENTITY_ID: "lock.online_with_unlatch_name"}
await hass.services.async_call(LOCK_DOMAIN, SERVICE_OPEN, data, blocking=True)
@ -185,7 +180,7 @@ async def test_open_lock_operation_pubnub_connected(
await hass.async_block_till_done()
await hass.async_block_till_done()
assert hass.states.get("lock.online_with_unlatch_name").state == STATE_UNLOCKED
assert hass.states.get("lock.online_with_unlatch_name").state == LockState.UNLOCKED
await hass.async_block_till_done()
@ -204,7 +199,7 @@ async def test_one_lock_operation_pubnub_connected(
lock_state = hass.states.get("lock.online_with_doorsense_name")
assert lock_state.state == STATE_LOCKED
assert lock_state.state == LockState.LOCKED
assert lock_state.attributes["battery_level"] == 92
assert lock_state.attributes["friendly_name"] == "online_with_doorsense Name"
@ -226,7 +221,7 @@ async def test_one_lock_operation_pubnub_connected(
await hass.async_block_till_done()
lock_state = hass.states.get("lock.online_with_doorsense_name")
assert lock_state.state == STATE_UNLOCKED
assert lock_state.state == LockState.UNLOCKED
assert lock_state.attributes["battery_level"] == 92
assert lock_state.attributes["friendly_name"] == "online_with_doorsense Name"
@ -247,7 +242,7 @@ async def test_one_lock_operation_pubnub_connected(
await hass.async_block_till_done()
lock_state = hass.states.get("lock.online_with_doorsense_name")
assert lock_state.state == STATE_LOCKED
assert lock_state.state == LockState.LOCKED
# No activity means it will be unavailable until the activity feed has data
lock_operator_sensor = entity_registry.async_get(
@ -274,7 +269,7 @@ async def test_one_lock_operation_pubnub_connected(
await hass.async_block_till_done()
lock_state = hass.states.get("lock.online_with_doorsense_name")
assert lock_state.state == STATE_UNLOCKED
assert lock_state.state == LockState.UNLOCKED
async def test_lock_jammed(hass: HomeAssistant) -> None:
@ -294,7 +289,7 @@ async def test_lock_jammed(hass: HomeAssistant) -> None:
lock_state = hass.states.get("lock.online_with_doorsense_name")
assert lock_state.state == STATE_LOCKED
assert lock_state.state == LockState.LOCKED
assert lock_state.attributes["battery_level"] == 92
assert lock_state.attributes["friendly_name"] == "online_with_doorsense Name"
@ -303,7 +298,7 @@ async def test_lock_jammed(hass: HomeAssistant) -> None:
await hass.services.async_call(LOCK_DOMAIN, SERVICE_UNLOCK, data, blocking=True)
lock_state = hass.states.get("lock.online_with_doorsense_name")
assert lock_state.state == STATE_JAMMED
assert lock_state.state == LockState.JAMMED
async def test_lock_throws_exception_on_unknown_status_code(
@ -325,7 +320,7 @@ async def test_lock_throws_exception_on_unknown_status_code(
lock_state = hass.states.get("lock.online_with_doorsense_name")
assert lock_state.state == STATE_LOCKED
assert lock_state.state == LockState.LOCKED
assert lock_state.attributes["battery_level"] == 92
assert lock_state.attributes["friendly_name"] == "online_with_doorsense Name"
@ -367,7 +362,7 @@ async def test_lock_bridge_online(hass: HomeAssistant) -> None:
)
await _create_august_with_devices(hass, [lock_one], activities=activities)
assert hass.states.get("lock.online_with_doorsense_name").state == STATE_LOCKED
assert hass.states.get("lock.online_with_doorsense_name").state == LockState.LOCKED
async def test_lock_update_via_pubnub(hass: HomeAssistant) -> None:
@ -383,7 +378,7 @@ async def test_lock_update_via_pubnub(hass: HomeAssistant) -> None:
)
pubnub.connected = True
assert states.get("lock.online_with_doorsense_name").state == STATE_LOCKED
assert states.get("lock.online_with_doorsense_name").state == LockState.LOCKED
pubnub.message(
pubnub,
@ -399,7 +394,7 @@ async def test_lock_update_via_pubnub(hass: HomeAssistant) -> None:
await hass.async_block_till_done()
await hass.async_block_till_done()
assert states.get("lock.online_with_doorsense_name").state == STATE_UNLOCKING
assert states.get("lock.online_with_doorsense_name").state == LockState.UNLOCKING
pubnub.message(
pubnub,
@ -415,21 +410,21 @@ async def test_lock_update_via_pubnub(hass: HomeAssistant) -> None:
await hass.async_block_till_done()
await hass.async_block_till_done()
assert states.get("lock.online_with_doorsense_name").state == STATE_LOCKING
assert states.get("lock.online_with_doorsense_name").state == LockState.LOCKING
async_fire_time_changed(hass, dt_util.utcnow() + datetime.timedelta(seconds=30))
await hass.async_block_till_done()
assert hass.states.get("lock.online_with_doorsense_name").state == STATE_LOCKING
assert hass.states.get("lock.online_with_doorsense_name").state == LockState.LOCKING
pubnub.connected = True
async_fire_time_changed(hass, dt_util.utcnow() + datetime.timedelta(seconds=30))
await hass.async_block_till_done()
assert states.get("lock.online_with_doorsense_name").state == STATE_LOCKING
assert states.get("lock.online_with_doorsense_name").state == LockState.LOCKING
# Ensure pubnub status is always preserved
async_fire_time_changed(hass, dt_util.utcnow() + datetime.timedelta(hours=2))
await hass.async_block_till_done()
assert states.get("lock.online_with_doorsense_name").state == STATE_LOCKING
assert states.get("lock.online_with_doorsense_name").state == LockState.LOCKING
pubnub.message(
pubnub,
@ -444,11 +439,11 @@ async def test_lock_update_via_pubnub(hass: HomeAssistant) -> None:
await hass.async_block_till_done()
await hass.async_block_till_done()
assert states.get("lock.online_with_doorsense_name").state == STATE_UNLOCKING
assert states.get("lock.online_with_doorsense_name").state == LockState.UNLOCKING
async_fire_time_changed(hass, dt_util.utcnow() + datetime.timedelta(hours=4))
await hass.async_block_till_done()
assert states.get("lock.online_with_doorsense_name").state == STATE_UNLOCKING
assert states.get("lock.online_with_doorsense_name").state == LockState.UNLOCKING
await hass.config_entries.async_unload(config_entry.entry_id)
await hass.async_block_till_done()

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

@ -8,8 +8,9 @@ from homeassistant.components.lock import (
DOMAIN as LOCK_DOMAIN,
SERVICE_LOCK,
SERVICE_UNLOCK,
LockState,
)
from homeassistant.const import ATTR_ENTITY_ID, STATE_LOCKED, STATE_UNLOCKED
from homeassistant.const import ATTR_ENTITY_ID
from homeassistant.core import HomeAssistant
from .conftest import WebsocketDataType
@ -43,10 +44,10 @@ async def test_lock_from_light(
) -> None:
"""Test that all supported lock entities based on lights are created."""
assert len(hass.states.async_all()) == 1
assert hass.states.get("lock.door_lock").state == STATE_UNLOCKED
assert hass.states.get("lock.door_lock").state == LockState.UNLOCKED
await light_ws_data({"state": {"on": True}})
assert hass.states.get("lock.door_lock").state == STATE_LOCKED
assert hass.states.get("lock.door_lock").state == LockState.LOCKED
# Verify service calls
@ -107,10 +108,10 @@ async def test_lock_from_sensor(
) -> None:
"""Test that all supported lock entities based on sensors are created."""
assert len(hass.states.async_all()) == 2
assert hass.states.get("lock.door_lock").state == STATE_UNLOCKED
assert hass.states.get("lock.door_lock").state == LockState.UNLOCKED
await sensor_ws_data({"state": {"lockstate": "locked"}})
assert hass.states.get("lock.door_lock").state == STATE_LOCKED
assert hass.states.get("lock.door_lock").state == LockState.LOCKED
# Verify service calls

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

@ -10,19 +10,9 @@ from homeassistant.components.lock import (
SERVICE_LOCK,
SERVICE_OPEN,
SERVICE_UNLOCK,
STATE_JAMMED,
STATE_LOCKED,
STATE_LOCKING,
STATE_UNLOCKED,
STATE_UNLOCKING,
)
from homeassistant.const import (
ATTR_ENTITY_ID,
EVENT_STATE_CHANGED,
STATE_OPEN,
STATE_OPENING,
Platform,
LockState,
)
from homeassistant.const import ATTR_ENTITY_ID, EVENT_STATE_CHANGED, Platform
from homeassistant.core import HomeAssistant
from homeassistant.setup import async_setup_component
@ -57,7 +47,7 @@ async def setup_comp(hass: HomeAssistant, lock_only: None):
async def test_locking(hass: HomeAssistant) -> None:
"""Test the locking of a lock."""
state = hass.states.get(KITCHEN)
assert state.state == STATE_UNLOCKED
assert state.state == LockState.UNLOCKED
await hass.async_block_till_done()
state_changes = async_capture_events(hass, EVENT_STATE_CHANGED)
@ -67,17 +57,17 @@ async def test_locking(hass: HomeAssistant) -> None:
await hass.async_block_till_done()
assert state_changes[0].data["entity_id"] == KITCHEN
assert state_changes[0].data["new_state"].state == STATE_LOCKING
assert state_changes[0].data["new_state"].state == LockState.LOCKING
assert state_changes[1].data["entity_id"] == KITCHEN
assert state_changes[1].data["new_state"].state == STATE_LOCKED
assert state_changes[1].data["new_state"].state == LockState.LOCKED
@patch.object(demo_lock, "LOCK_UNLOCK_DELAY", 0)
async def test_unlocking(hass: HomeAssistant) -> None:
"""Test the unlocking of a lock."""
state = hass.states.get(FRONT)
assert state.state == STATE_LOCKED
assert state.state == LockState.LOCKED
await hass.async_block_till_done()
state_changes = async_capture_events(hass, EVENT_STATE_CHANGED)
@ -87,17 +77,17 @@ async def test_unlocking(hass: HomeAssistant) -> None:
await hass.async_block_till_done()
assert state_changes[0].data["entity_id"] == FRONT
assert state_changes[0].data["new_state"].state == STATE_UNLOCKING
assert state_changes[0].data["new_state"].state == LockState.UNLOCKING
assert state_changes[1].data["entity_id"] == FRONT
assert state_changes[1].data["new_state"].state == STATE_UNLOCKED
assert state_changes[1].data["new_state"].state == LockState.UNLOCKED
@patch.object(demo_lock, "LOCK_UNLOCK_DELAY", 0)
async def test_opening(hass: HomeAssistant) -> None:
"""Test the opening of a lock."""
state = hass.states.get(OPENABLE_LOCK)
assert state.state == STATE_LOCKED
assert state.state == LockState.LOCKED
await hass.async_block_till_done()
state_changes = async_capture_events(hass, EVENT_STATE_CHANGED)
@ -107,17 +97,17 @@ async def test_opening(hass: HomeAssistant) -> None:
await hass.async_block_till_done()
assert state_changes[0].data["entity_id"] == OPENABLE_LOCK
assert state_changes[0].data["new_state"].state == STATE_OPENING
assert state_changes[0].data["new_state"].state == LockState.OPENING
assert state_changes[1].data["entity_id"] == OPENABLE_LOCK
assert state_changes[1].data["new_state"].state == STATE_OPEN
assert state_changes[1].data["new_state"].state == LockState.OPEN
@patch.object(demo_lock, "LOCK_UNLOCK_DELAY", 0)
async def test_jammed_when_locking(hass: HomeAssistant) -> None:
"""Test the locking of a lock jams."""
state = hass.states.get(POORLY_INSTALLED)
assert state.state == STATE_UNLOCKED
assert state.state == LockState.UNLOCKED
await hass.async_block_till_done()
state_changes = async_capture_events(hass, EVENT_STATE_CHANGED)
@ -127,10 +117,10 @@ async def test_jammed_when_locking(hass: HomeAssistant) -> None:
await hass.async_block_till_done()
assert state_changes[0].data["entity_id"] == POORLY_INSTALLED
assert state_changes[0].data["new_state"].state == STATE_LOCKING
assert state_changes[0].data["new_state"].state == LockState.LOCKING
assert state_changes[1].data["entity_id"] == POORLY_INSTALLED
assert state_changes[1].data["new_state"].state == STATE_JAMMED
assert state_changes[1].data["new_state"].state == LockState.JAMMED
async def test_opening_mocked(hass: HomeAssistant) -> None:

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

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

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

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

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)
trt = trait.LockUnlockTrait(
hass, State("lock.front_door", lock.STATE_LOCKED), PIN_CONFIG
hass, State("lock.front_door", lock.LockState.LOCKED), PIN_CONFIG
)
assert trt.sync_attributes() == {}
@ -1628,7 +1628,7 @@ async def test_lock_unlock_unlocking(hass: HomeAssistant) -> None:
assert trait.LockUnlockTrait.might_2fa(lock.DOMAIN, LockEntityFeature.OPEN, None)
trt = trait.LockUnlockTrait(
hass, State("lock.front_door", lock.STATE_UNLOCKING), PIN_CONFIG
hass, State("lock.front_door", lock.LockState.UNLOCKING), PIN_CONFIG
)
assert trt.sync_attributes() == {}
@ -1645,7 +1645,7 @@ async def test_lock_unlock_lock_jammed(hass: HomeAssistant) -> None:
assert trait.LockUnlockTrait.might_2fa(lock.DOMAIN, LockEntityFeature.OPEN, None)
trt = trait.LockUnlockTrait(
hass, State("lock.front_door", lock.STATE_JAMMED), PIN_CONFIG
hass, State("lock.front_door", lock.LockState.JAMMED), PIN_CONFIG
)
assert trt.sync_attributes() == {}
@ -1670,7 +1670,7 @@ async def test_lock_unlock_unlock(hass: HomeAssistant) -> None:
)
trt = trait.LockUnlockTrait(
hass, State("lock.front_door", lock.STATE_LOCKED), PIN_CONFIG
hass, State("lock.front_door", lock.LockState.LOCKED), PIN_CONFIG
)
assert trt.sync_attributes() == {}
@ -1706,7 +1706,7 @@ async def test_lock_unlock_unlock(hass: HomeAssistant) -> None:
# Test without pin
trt = trait.LockUnlockTrait(
hass, State("lock.front_door", lock.STATE_LOCKED), BASIC_CONFIG
hass, State("lock.front_door", lock.LockState.LOCKED), BASIC_CONFIG
)
with pytest.raises(error.SmartHomeError) as err:

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

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

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

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

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.type_locks import Lock
from homeassistant.components.lock import (
DOMAIN as LOCK_DOMAIN,
STATE_JAMMED,
STATE_LOCKING,
STATE_UNLOCKING,
)
from homeassistant.components.lock import DOMAIN as LOCK_DOMAIN, LockState
from homeassistant.const import (
ATTR_CODE,
ATTR_ENTITY_ID,
STATE_LOCKED,
STATE_UNAVAILABLE,
STATE_UNKNOWN,
STATE_UNLOCKED,
)
from homeassistant.core import Event, HomeAssistant
@ -40,27 +33,27 @@ async def test_lock_unlock(hass: HomeAssistant, hk_driver, events: list[Event])
assert acc.char_current_state.value == 3
assert acc.char_target_state.value == 1
hass.states.async_set(entity_id, STATE_LOCKED)
hass.states.async_set(entity_id, LockState.LOCKED)
await hass.async_block_till_done()
assert acc.char_current_state.value == 1
assert acc.char_target_state.value == 1
hass.states.async_set(entity_id, STATE_LOCKING)
hass.states.async_set(entity_id, LockState.LOCKING)
await hass.async_block_till_done()
assert acc.char_current_state.value == 0
assert acc.char_target_state.value == 1
hass.states.async_set(entity_id, STATE_UNLOCKED)
hass.states.async_set(entity_id, LockState.UNLOCKED)
await hass.async_block_till_done()
assert acc.char_current_state.value == 0
assert acc.char_target_state.value == 0
hass.states.async_set(entity_id, STATE_UNLOCKING)
hass.states.async_set(entity_id, LockState.UNLOCKING)
await hass.async_block_till_done()
assert acc.char_current_state.value == 1
assert acc.char_target_state.value == 0
hass.states.async_set(entity_id, STATE_JAMMED)
hass.states.async_set(entity_id, LockState.JAMMED)
await hass.async_block_till_done()
assert acc.char_current_state.value == 2
assert acc.char_target_state.value == 0
@ -78,7 +71,7 @@ async def test_lock_unlock(hass: HomeAssistant, hk_driver, events: list[Event])
assert acc.char_target_state.value == 0
assert acc.available is False
hass.states.async_set(entity_id, STATE_UNLOCKED)
hass.states.async_set(entity_id, LockState.UNLOCKED)
await hass.async_block_till_done()
assert acc.char_current_state.value == 0
assert acc.char_target_state.value == 0

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

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

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

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

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

@ -11,17 +11,9 @@ from homeassistant.components.lock import (
SERVICE_LOCK,
SERVICE_OPEN,
SERVICE_UNLOCK,
STATE_LOCKED,
STATE_LOCKING,
STATE_UNLOCKED,
STATE_UNLOCKING,
)
from homeassistant.const import (
ATTR_ENTITY_ID,
EVENT_STATE_CHANGED,
STATE_OPEN,
Platform,
LockState,
)
from homeassistant.const import ATTR_ENTITY_ID, EVENT_STATE_CHANGED, Platform
from homeassistant.core import HomeAssistant
from homeassistant.setup import async_setup_component
@ -58,7 +50,7 @@ async def test_states(hass: HomeAssistant, snapshot: SnapshotAssertion) -> None:
async def test_locking(hass: HomeAssistant) -> None:
"""Test the locking of a lock."""
state = hass.states.get(UNLOCKED_LOCK)
assert state.state == STATE_UNLOCKED
assert state.state == LockState.UNLOCKED
await hass.async_block_till_done()
state_changes = async_capture_events(hass, EVENT_STATE_CHANGED)
@ -68,16 +60,16 @@ async def test_locking(hass: HomeAssistant) -> None:
await hass.async_block_till_done()
assert state_changes[0].data["entity_id"] == UNLOCKED_LOCK
assert state_changes[0].data["new_state"].state == STATE_LOCKING
assert state_changes[0].data["new_state"].state == LockState.LOCKING
assert state_changes[1].data["entity_id"] == UNLOCKED_LOCK
assert state_changes[1].data["new_state"].state == STATE_LOCKED
assert state_changes[1].data["new_state"].state == LockState.LOCKED
async def test_unlocking(hass: HomeAssistant) -> None:
"""Test the unlocking of a lock."""
state = hass.states.get(LOCKED_LOCK)
assert state.state == STATE_LOCKED
assert state.state == LockState.LOCKED
await hass.async_block_till_done()
state_changes = async_capture_events(hass, EVENT_STATE_CHANGED)
@ -87,10 +79,10 @@ async def test_unlocking(hass: HomeAssistant) -> None:
await hass.async_block_till_done()
assert state_changes[0].data["entity_id"] == LOCKED_LOCK
assert state_changes[0].data["new_state"].state == STATE_UNLOCKING
assert state_changes[0].data["new_state"].state == LockState.UNLOCKING
assert state_changes[1].data["entity_id"] == LOCKED_LOCK
assert state_changes[1].data["new_state"].state == STATE_UNLOCKED
assert state_changes[1].data["new_state"].state == LockState.UNLOCKED
async def test_opening_mocked(hass: HomeAssistant) -> None:
@ -108,4 +100,4 @@ async def test_opening(hass: HomeAssistant) -> None:
LOCK_DOMAIN, SERVICE_OPEN, {ATTR_ENTITY_ID: OPENABLE_LOCK}, blocking=True
)
state = hass.states.get(OPENABLE_LOCK)
assert state.state == STATE_OPEN
assert state.state == LockState.OPEN

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

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.device_automation import DeviceAutomationType
from homeassistant.components.lock import DOMAIN, LockEntityFeature
from homeassistant.const import (
STATE_JAMMED,
STATE_LOCKED,
STATE_LOCKING,
STATE_OPEN,
STATE_OPENING,
STATE_UNLOCKED,
STATE_UNLOCKING,
EntityCategory,
)
from homeassistant.components.lock import DOMAIN, LockEntityFeature, LockState
from homeassistant.const import EntityCategory
from homeassistant.core import HomeAssistant, ServiceCall
from homeassistant.helpers import device_registry as dr, entity_registry as er
from homeassistant.helpers.entity_registry import RegistryEntryHider
@ -218,7 +209,7 @@ async def test_if_fires_on_state_change(
DOMAIN, "test", "5678", device_id=device_entry.id
)
hass.states.async_set(entry.entity_id, STATE_UNLOCKED)
hass.states.async_set(entry.entity_id, LockState.UNLOCKED)
assert await async_setup_component(
hass,
@ -287,7 +278,7 @@ async def test_if_fires_on_state_change(
)
# Fake that the entity is turning on.
hass.states.async_set(entry.entity_id, STATE_LOCKED)
hass.states.async_set(entry.entity_id, LockState.LOCKED)
await hass.async_block_till_done()
assert len(service_calls) == 1
assert (
@ -296,7 +287,7 @@ async def test_if_fires_on_state_change(
)
# Fake that the entity is turning off.
hass.states.async_set(entry.entity_id, STATE_UNLOCKED)
hass.states.async_set(entry.entity_id, LockState.UNLOCKED)
await hass.async_block_till_done()
assert len(service_calls) == 2
assert (
@ -305,7 +296,7 @@ async def test_if_fires_on_state_change(
)
# Fake that the entity is opens.
hass.states.async_set(entry.entity_id, STATE_OPEN)
hass.states.async_set(entry.entity_id, LockState.OPEN)
await hass.async_block_till_done()
assert len(service_calls) == 3
assert (
@ -331,7 +322,7 @@ async def test_if_fires_on_state_change_legacy(
DOMAIN, "test", "5678", device_id=device_entry.id
)
hass.states.async_set(entry.entity_id, STATE_UNLOCKED)
hass.states.async_set(entry.entity_id, LockState.UNLOCKED)
assert await async_setup_component(
hass,
@ -362,7 +353,7 @@ async def test_if_fires_on_state_change_legacy(
)
# Fake that the entity is turning on.
hass.states.async_set(entry.entity_id, STATE_LOCKED)
hass.states.async_set(entry.entity_id, LockState.LOCKED)
await hass.async_block_till_done()
assert len(service_calls) == 1
assert (
@ -388,7 +379,7 @@ async def test_if_fires_on_state_change_with_for(
DOMAIN, "test", "5678", device_id=device_entry.id
)
hass.states.async_set(entry.entity_id, STATE_UNLOCKED)
hass.states.async_set(entry.entity_id, LockState.UNLOCKED)
assert await async_setup_component(
hass,
@ -511,7 +502,7 @@ async def test_if_fires_on_state_change_with_for(
await hass.async_block_till_done()
assert len(service_calls) == 0
hass.states.async_set(entry.entity_id, STATE_LOCKED)
hass.states.async_set(entry.entity_id, LockState.LOCKED)
await hass.async_block_till_done()
assert len(service_calls) == 0
async_fire_time_changed(hass, dt_util.utcnow() + timedelta(seconds=10))
@ -523,7 +514,7 @@ async def test_if_fires_on_state_change_with_for(
== f"turn_off device - {entry.entity_id} - unlocked - locked - 0:00:05"
)
hass.states.async_set(entry.entity_id, STATE_UNLOCKING)
hass.states.async_set(entry.entity_id, LockState.UNLOCKING)
await hass.async_block_till_done()
assert len(service_calls) == 1
async_fire_time_changed(hass, dt_util.utcnow() + timedelta(seconds=16))
@ -535,7 +526,7 @@ async def test_if_fires_on_state_change_with_for(
== f"turn_on device - {entry.entity_id} - locked - unlocking - 0:00:05"
)
hass.states.async_set(entry.entity_id, STATE_JAMMED)
hass.states.async_set(entry.entity_id, LockState.JAMMED)
await hass.async_block_till_done()
assert len(service_calls) == 2
async_fire_time_changed(hass, dt_util.utcnow() + timedelta(seconds=21))
@ -547,7 +538,7 @@ async def test_if_fires_on_state_change_with_for(
== f"turn_off device - {entry.entity_id} - unlocking - jammed - 0:00:05"
)
hass.states.async_set(entry.entity_id, STATE_LOCKING)
hass.states.async_set(entry.entity_id, LockState.LOCKING)
await hass.async_block_till_done()
assert len(service_calls) == 3
async_fire_time_changed(hass, dt_util.utcnow() + timedelta(seconds=27))
@ -559,7 +550,7 @@ async def test_if_fires_on_state_change_with_for(
== f"turn_on device - {entry.entity_id} - jammed - locking - 0:00:05"
)
hass.states.async_set(entry.entity_id, STATE_OPENING)
hass.states.async_set(entry.entity_id, LockState.OPENING)
await hass.async_block_till_done()
assert len(service_calls) == 4
async_fire_time_changed(hass, dt_util.utcnow() + timedelta(seconds=27))

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

@ -2,6 +2,7 @@
from __future__ import annotations
from enum import Enum
import re
from typing import Any
@ -15,14 +16,9 @@ from homeassistant.components.lock import (
SERVICE_LOCK,
SERVICE_OPEN,
SERVICE_UNLOCK,
STATE_JAMMED,
STATE_LOCKED,
STATE_LOCKING,
STATE_UNLOCKED,
STATE_UNLOCKING,
LockEntityFeature,
LockState,
)
from homeassistant.const import STATE_OPEN, STATE_OPENING
from homeassistant.core import HomeAssistant
from homeassistant.exceptions import ServiceValidationError
import homeassistant.helpers.entity_registry as er
@ -67,37 +63,37 @@ async def test_lock_states(hass: HomeAssistant, mock_lock_entity: MockLock) -> N
mock_lock_entity._attr_is_locking = True
assert mock_lock_entity.is_locking
assert mock_lock_entity.state == STATE_LOCKING
assert mock_lock_entity.state == LockState.LOCKING
mock_lock_entity._attr_is_locked = True
mock_lock_entity._attr_is_locking = False
assert mock_lock_entity.is_locked
assert mock_lock_entity.state == STATE_LOCKED
assert mock_lock_entity.state == LockState.LOCKED
mock_lock_entity._attr_is_unlocking = True
assert mock_lock_entity.is_unlocking
assert mock_lock_entity.state == STATE_UNLOCKING
assert mock_lock_entity.state == LockState.UNLOCKING
mock_lock_entity._attr_is_locked = False
mock_lock_entity._attr_is_unlocking = False
assert not mock_lock_entity.is_locked
assert mock_lock_entity.state == STATE_UNLOCKED
assert mock_lock_entity.state == LockState.UNLOCKED
mock_lock_entity._attr_is_jammed = True
assert mock_lock_entity.is_jammed
assert mock_lock_entity.state == STATE_JAMMED
assert mock_lock_entity.state == LockState.JAMMED
assert not mock_lock_entity.is_locked
mock_lock_entity._attr_is_jammed = False
mock_lock_entity._attr_is_opening = True
assert mock_lock_entity.is_opening
assert mock_lock_entity.state == STATE_OPENING
assert mock_lock_entity.state == LockState.OPENING
assert mock_lock_entity.is_opening
mock_lock_entity._attr_is_opening = False
mock_lock_entity._attr_is_open = True
assert not mock_lock_entity.is_opening
assert mock_lock_entity.state == STATE_OPEN
assert mock_lock_entity.state == LockState.OPEN
assert not mock_lock_entity.is_opening
assert mock_lock_entity.is_open
@ -393,13 +389,35 @@ def test_all() -> None:
help_test_all(lock)
@pytest.mark.parametrize(("enum"), list(LockEntityFeature))
def _create_tuples(
enum: type[Enum], constant_prefix: str, remove_in_version: str
) -> list[tuple[Enum, str]]:
return [
(enum_field, constant_prefix, remove_in_version)
for enum_field in enum
if enum_field
not in [
lock.LockState.OPEN,
lock.LockState.OPENING,
]
]
@pytest.mark.parametrize(
("enum", "constant_prefix", "remove_in_version"),
_create_tuples(lock.LockEntityFeature, "SUPPORT_", "2025.1")
+ _create_tuples(lock.LockState, "STATE_", "2025.10"),
)
def test_deprecated_constants(
caplog: pytest.LogCaptureFixture,
enum: LockEntityFeature,
enum: Enum,
constant_prefix: str,
remove_in_version: str,
) -> None:
"""Test deprecated constants."""
import_and_test_deprecated_constant_enum(caplog, lock, enum, "SUPPORT_", "2025.1")
import_and_test_deprecated_constant_enum(
caplog, lock, enum, constant_prefix, remove_in_version
)
def test_deprecated_supported_features_ints(caplog: pytest.LogCaptureFixture) -> None:

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

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

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

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

@ -10,14 +10,8 @@ from homeassistant.components.lock import (
SERVICE_LOCK,
SERVICE_OPEN,
SERVICE_UNLOCK,
STATE_JAMMED,
STATE_LOCKED,
STATE_LOCKING,
STATE_OPEN,
STATE_OPENING,
STATE_UNLOCKED,
STATE_UNLOCKING,
LockEntityFeature,
LockState,
)
from homeassistant.components.mqtt.lock import MQTT_LOCK_ATTRIBUTES_BLOCKED
from homeassistant.const import (
@ -89,12 +83,12 @@ CONFIG_WITH_STATES = {
@pytest.mark.parametrize(
("hass_config", "payload", "lock_state"),
[
(CONFIG_WITH_STATES, "closed", STATE_LOCKED),
(CONFIG_WITH_STATES, "closing", STATE_LOCKING),
(CONFIG_WITH_STATES, "open", STATE_OPEN),
(CONFIG_WITH_STATES, "opening", STATE_OPENING),
(CONFIG_WITH_STATES, "unlocked", STATE_UNLOCKED),
(CONFIG_WITH_STATES, "unlocking", STATE_UNLOCKING),
(CONFIG_WITH_STATES, "closed", LockState.LOCKED),
(CONFIG_WITH_STATES, "closing", LockState.LOCKING),
(CONFIG_WITH_STATES, "open", LockState.OPEN),
(CONFIG_WITH_STATES, "opening", LockState.OPENING),
(CONFIG_WITH_STATES, "unlocked", LockState.UNLOCKED),
(CONFIG_WITH_STATES, "unlocking", LockState.UNLOCKING),
],
)
async def test_controlling_state_via_topic(
@ -115,18 +109,18 @@ async def test_controlling_state_via_topic(
await hass.async_block_till_done()
state = hass.states.get("lock.test")
assert state.state is lock_state
assert state.state == lock_state
@pytest.mark.parametrize(
("hass_config", "payload", "lock_state"),
[
(CONFIG_WITH_STATES, "closed", STATE_LOCKED),
(CONFIG_WITH_STATES, "closing", STATE_LOCKING),
(CONFIG_WITH_STATES, "open", STATE_OPEN),
(CONFIG_WITH_STATES, "opening", STATE_OPENING),
(CONFIG_WITH_STATES, "unlocked", STATE_UNLOCKED),
(CONFIG_WITH_STATES, "unlocking", STATE_UNLOCKING),
(CONFIG_WITH_STATES, "closed", LockState.LOCKED),
(CONFIG_WITH_STATES, "closing", LockState.LOCKING),
(CONFIG_WITH_STATES, "open", LockState.OPEN),
(CONFIG_WITH_STATES, "opening", LockState.OPENING),
(CONFIG_WITH_STATES, "unlocked", LockState.UNLOCKED),
(CONFIG_WITH_STATES, "unlocking", LockState.UNLOCKING),
(CONFIG_WITH_STATES, "None", STATE_UNKNOWN),
],
)
@ -146,13 +140,13 @@ async def test_controlling_non_default_state_via_topic(
async_fire_mqtt_message(hass, "state-topic", payload)
state = hass.states.get("lock.test")
assert state.state is lock_state
assert state.state == lock_state
# Empty state is ignored
async_fire_mqtt_message(hass, "state-topic", "")
state = hass.states.get("lock.test")
assert state.state is lock_state
assert state.state == lock_state
@pytest.mark.parametrize(
@ -165,7 +159,7 @@ async def test_controlling_non_default_state_via_topic(
({"value_template": "{{ value_json.val }}"},),
),
'{"val":"closed"}',
STATE_LOCKED,
LockState.LOCKED,
),
(
help_custom_config(
@ -174,7 +168,7 @@ async def test_controlling_non_default_state_via_topic(
({"value_template": "{{ value_json.val }}"},),
),
'{"val":"closing"}',
STATE_LOCKING,
LockState.LOCKING,
),
(
help_custom_config(
@ -183,7 +177,7 @@ async def test_controlling_non_default_state_via_topic(
({"value_template": "{{ value_json.val }}"},),
),
'{"val":"unlocking"}',
STATE_UNLOCKING,
LockState.UNLOCKING,
),
(
help_custom_config(
@ -192,7 +186,7 @@ async def test_controlling_non_default_state_via_topic(
({"value_template": "{{ value_json.val }}"},),
),
'{"val":"open"}',
STATE_OPEN,
LockState.OPEN,
),
(
help_custom_config(
@ -201,7 +195,7 @@ async def test_controlling_non_default_state_via_topic(
({"value_template": "{{ value_json.val }}"},),
),
'{"val":"opening"}',
STATE_OPENING,
LockState.OPENING,
),
(
help_custom_config(
@ -210,7 +204,7 @@ async def test_controlling_non_default_state_via_topic(
({"value_template": "{{ value_json.val }}"},),
),
'{"val":"unlocked"}',
STATE_UNLOCKED,
LockState.UNLOCKED,
),
(
help_custom_config(
@ -238,7 +232,7 @@ async def test_controlling_state_via_topic_and_json_message(
async_fire_mqtt_message(hass, "state-topic", payload)
state = hass.states.get("lock.test")
assert state.state is lock_state
assert state.state == lock_state
@pytest.mark.parametrize(
@ -251,7 +245,7 @@ async def test_controlling_state_via_topic_and_json_message(
({"value_template": "{{ value_json.val }}"},),
),
'{"val":"closed"}',
STATE_LOCKED,
LockState.LOCKED,
),
(
help_custom_config(
@ -260,7 +254,7 @@ async def test_controlling_state_via_topic_and_json_message(
({"value_template": "{{ value_json.val }}"},),
),
'{"val":"closing"}',
STATE_LOCKING,
LockState.LOCKING,
),
(
help_custom_config(
@ -269,7 +263,7 @@ async def test_controlling_state_via_topic_and_json_message(
({"value_template": "{{ value_json.val }}"},),
),
'{"val":"open"}',
STATE_OPEN,
LockState.OPEN,
),
(
help_custom_config(
@ -278,7 +272,7 @@ async def test_controlling_state_via_topic_and_json_message(
({"value_template": "{{ value_json.val }}"},),
),
'{"val":"opening"}',
STATE_OPENING,
LockState.OPENING,
),
(
help_custom_config(
@ -287,7 +281,7 @@ async def test_controlling_state_via_topic_and_json_message(
({"value_template": "{{ value_json.val }}"},),
),
'{"val":"unlocked"}',
STATE_UNLOCKED,
LockState.UNLOCKED,
),
(
help_custom_config(
@ -296,7 +290,7 @@ async def test_controlling_state_via_topic_and_json_message(
({"value_template": "{{ value_json.val }}"},),
),
'{"val":"unlocking"}',
STATE_UNLOCKING,
LockState.UNLOCKING,
),
],
)
@ -315,7 +309,7 @@ async def test_controlling_non_default_state_via_topic_and_json_message(
async_fire_mqtt_message(hass, "state-topic", payload)
state = hass.states.get("lock.test")
assert state.state is lock_state
assert state.state == lock_state
@pytest.mark.parametrize(
@ -342,7 +336,7 @@ async def test_sending_mqtt_commands_and_optimistic(
mqtt_mock = await mqtt_mock_entry()
state = hass.states.get("lock.test")
assert state.state is STATE_UNLOCKED
assert state.state == LockState.UNLOCKED
assert state.attributes.get(ATTR_ASSUMED_STATE)
await hass.services.async_call(
@ -352,7 +346,7 @@ async def test_sending_mqtt_commands_and_optimistic(
mqtt_mock.async_publish.assert_called_once_with("command-topic", "LOCK", 0, False)
mqtt_mock.async_publish.reset_mock()
state = hass.states.get("lock.test")
assert state.state is STATE_LOCKED
assert state.state == LockState.LOCKED
assert state.attributes.get(ATTR_ASSUMED_STATE)
await hass.services.async_call(
@ -362,7 +356,7 @@ async def test_sending_mqtt_commands_and_optimistic(
mqtt_mock.async_publish.assert_called_once_with("command-topic", "UNLOCK", 0, False)
mqtt_mock.async_publish.reset_mock()
state = hass.states.get("lock.test")
assert state.state is STATE_UNLOCKED
assert state.state == LockState.UNLOCKED
assert state.attributes.get(ATTR_ASSUMED_STATE)
@ -393,7 +387,7 @@ async def test_sending_mqtt_commands_with_template(
mqtt_mock = await mqtt_mock_entry()
state = hass.states.get("lock.test")
assert state.state is STATE_UNLOCKED
assert state.state == LockState.UNLOCKED
assert state.attributes.get(ATTR_ASSUMED_STATE)
await hass.services.async_call(
@ -408,7 +402,7 @@ async def test_sending_mqtt_commands_with_template(
)
mqtt_mock.async_publish.reset_mock()
state = hass.states.get("lock.test")
assert state.state is STATE_LOCKED
assert state.state == LockState.LOCKED
assert state.attributes.get(ATTR_ASSUMED_STATE)
await hass.services.async_call(
@ -423,7 +417,7 @@ async def test_sending_mqtt_commands_with_template(
)
mqtt_mock.async_publish.reset_mock()
state = hass.states.get("lock.test")
assert state.state is STATE_UNLOCKED
assert state.state == LockState.UNLOCKED
assert state.attributes.get(ATTR_ASSUMED_STATE)
@ -453,7 +447,7 @@ async def test_sending_mqtt_commands_and_explicit_optimistic(
mqtt_mock = await mqtt_mock_entry()
state = hass.states.get("lock.test")
assert state.state is STATE_UNLOCKED
assert state.state == LockState.UNLOCKED
assert state.attributes.get(ATTR_ASSUMED_STATE)
await hass.services.async_call(
@ -463,7 +457,7 @@ async def test_sending_mqtt_commands_and_explicit_optimistic(
mqtt_mock.async_publish.assert_called_once_with("command-topic", "LOCK", 0, False)
mqtt_mock.async_publish.reset_mock()
state = hass.states.get("lock.test")
assert state.state is STATE_LOCKED
assert state.state == LockState.LOCKED
assert state.attributes.get(ATTR_ASSUMED_STATE)
await hass.services.async_call(
@ -473,7 +467,7 @@ async def test_sending_mqtt_commands_and_explicit_optimistic(
mqtt_mock.async_publish.assert_called_once_with("command-topic", "UNLOCK", 0, False)
mqtt_mock.async_publish.reset_mock()
state = hass.states.get("lock.test")
assert state.state is STATE_UNLOCKED
assert state.state == LockState.UNLOCKED
assert state.attributes.get(ATTR_ASSUMED_STATE)
@ -502,7 +496,7 @@ async def test_sending_mqtt_commands_support_open_and_optimistic(
mqtt_mock = await mqtt_mock_entry()
state = hass.states.get("lock.test")
assert state.state is STATE_UNLOCKED
assert state.state == LockState.UNLOCKED
assert state.attributes.get(ATTR_ASSUMED_STATE)
assert state.attributes.get(ATTR_SUPPORTED_FEATURES) == LockEntityFeature.OPEN
@ -513,7 +507,7 @@ async def test_sending_mqtt_commands_support_open_and_optimistic(
mqtt_mock.async_publish.assert_called_once_with("command-topic", "LOCK", 0, False)
mqtt_mock.async_publish.reset_mock()
state = hass.states.get("lock.test")
assert state.state is STATE_LOCKED
assert state.state == LockState.LOCKED
assert state.attributes.get(ATTR_ASSUMED_STATE)
await hass.services.async_call(
@ -523,7 +517,7 @@ async def test_sending_mqtt_commands_support_open_and_optimistic(
mqtt_mock.async_publish.assert_called_once_with("command-topic", "UNLOCK", 0, False)
mqtt_mock.async_publish.reset_mock()
state = hass.states.get("lock.test")
assert state.state is STATE_UNLOCKED
assert state.state == LockState.UNLOCKED
assert state.attributes.get(ATTR_ASSUMED_STATE)
await hass.services.async_call(
@ -533,7 +527,7 @@ async def test_sending_mqtt_commands_support_open_and_optimistic(
mqtt_mock.async_publish.assert_called_once_with("command-topic", "OPEN", 0, False)
mqtt_mock.async_publish.reset_mock()
state = hass.states.get("lock.test")
assert state.state is STATE_OPEN
assert state.state == LockState.OPEN
assert state.attributes.get(ATTR_ASSUMED_STATE)
@ -564,7 +558,7 @@ async def test_sending_mqtt_commands_support_open_and_explicit_optimistic(
mqtt_mock = await mqtt_mock_entry()
state = hass.states.get("lock.test")
assert state.state is STATE_UNLOCKED
assert state.state == LockState.UNLOCKED
assert state.attributes.get(ATTR_ASSUMED_STATE)
assert state.attributes.get(ATTR_SUPPORTED_FEATURES) == LockEntityFeature.OPEN
@ -575,7 +569,7 @@ async def test_sending_mqtt_commands_support_open_and_explicit_optimistic(
mqtt_mock.async_publish.assert_called_once_with("command-topic", "LOCK", 0, False)
mqtt_mock.async_publish.reset_mock()
state = hass.states.get("lock.test")
assert state.state is STATE_LOCKED
assert state.state == LockState.LOCKED
assert state.attributes.get(ATTR_ASSUMED_STATE)
await hass.services.async_call(
@ -585,7 +579,7 @@ async def test_sending_mqtt_commands_support_open_and_explicit_optimistic(
mqtt_mock.async_publish.assert_called_once_with("command-topic", "UNLOCK", 0, False)
mqtt_mock.async_publish.reset_mock()
state = hass.states.get("lock.test")
assert state.state is STATE_UNLOCKED
assert state.state == LockState.UNLOCKED
assert state.attributes.get(ATTR_ASSUMED_STATE)
await hass.services.async_call(
@ -595,7 +589,7 @@ async def test_sending_mqtt_commands_support_open_and_explicit_optimistic(
mqtt_mock.async_publish.assert_called_once_with("command-topic", "OPEN", 0, False)
mqtt_mock.async_publish.reset_mock()
state = hass.states.get("lock.test")
assert state.state is STATE_OPEN
assert state.state == LockState.OPEN
assert state.attributes.get(ATTR_ASSUMED_STATE)
@ -644,7 +638,7 @@ async def test_sending_mqtt_commands_pessimistic(
await hass.async_block_till_done()
state = hass.states.get("lock.test")
assert state.state is STATE_LOCKED
assert state.state == LockState.LOCKED
await hass.services.async_call(
lock.DOMAIN, SERVICE_UNLOCK, {ATTR_ENTITY_ID: "lock.test"}, blocking=True
@ -658,7 +652,7 @@ async def test_sending_mqtt_commands_pessimistic(
await hass.async_block_till_done()
state = hass.states.get("lock.test")
assert state.state is STATE_UNLOCKED
assert state.state == LockState.UNLOCKED
await hass.services.async_call(
lock.DOMAIN, SERVICE_OPEN, {ATTR_ENTITY_ID: "lock.test"}, blocking=True
@ -672,7 +666,7 @@ async def test_sending_mqtt_commands_pessimistic(
await hass.async_block_till_done()
state = hass.states.get("lock.test")
assert state.state is STATE_UNLOCKED
assert state.state == LockState.UNLOCKED
# send lock command to lock
await hass.services.async_call(
@ -688,21 +682,21 @@ async def test_sending_mqtt_commands_pessimistic(
await hass.async_block_till_done()
state = hass.states.get("lock.test")
assert state.state is STATE_LOCKING
assert state.state == LockState.LOCKING
# receive jammed state from lock
async_fire_mqtt_message(hass, "state-topic", "JAMMED")
await hass.async_block_till_done()
state = hass.states.get("lock.test")
assert state.state is STATE_JAMMED
assert state.state == LockState.JAMMED
# receive solved state from lock
async_fire_mqtt_message(hass, "state-topic", "LOCKED")
await hass.async_block_till_done()
state = hass.states.get("lock.test")
assert state.state is STATE_LOCKED
assert state.state == LockState.LOCKED
@pytest.mark.parametrize("hass_config", [DEFAULT_CONFIG])

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

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

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

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

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

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

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

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

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

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

@ -1,6 +1,6 @@
"""Tests for the Switch as X Lock platform."""
from homeassistant.components.lock import DOMAIN as LOCK_DOMAIN
from homeassistant.components.lock import DOMAIN as LOCK_DOMAIN, LockState
from homeassistant.components.switch import DOMAIN as SWITCH_DOMAIN
from homeassistant.components.switch_as_x.config_flow import SwitchAsXConfigFlowHandler
from homeassistant.components.switch_as_x.const import (
@ -15,10 +15,8 @@ from homeassistant.const import (
SERVICE_TURN_OFF,
SERVICE_TURN_ON,
SERVICE_UNLOCK,
STATE_LOCKED,
STATE_OFF,
STATE_ON,
STATE_UNLOCKED,
Platform,
)
from homeassistant.core import HomeAssistant
@ -70,7 +68,7 @@ async def test_service_calls(hass: HomeAssistant) -> None:
assert await hass.config_entries.async_setup(config_entry.entry_id)
await hass.async_block_till_done()
assert hass.states.get("lock.decorative_lights").state == STATE_UNLOCKED
assert hass.states.get("lock.decorative_lights").state == LockState.UNLOCKED
await hass.services.async_call(
LOCK_DOMAIN,
@ -80,7 +78,7 @@ async def test_service_calls(hass: HomeAssistant) -> None:
)
assert hass.states.get("switch.decorative_lights").state == STATE_OFF
assert hass.states.get("lock.decorative_lights").state == STATE_LOCKED
assert hass.states.get("lock.decorative_lights").state == LockState.LOCKED
await hass.services.async_call(
LOCK_DOMAIN,
@ -90,7 +88,7 @@ async def test_service_calls(hass: HomeAssistant) -> None:
)
assert hass.states.get("switch.decorative_lights").state == STATE_ON
assert hass.states.get("lock.decorative_lights").state == STATE_UNLOCKED
assert hass.states.get("lock.decorative_lights").state == LockState.UNLOCKED
await hass.services.async_call(
SWITCH_DOMAIN,
@ -100,7 +98,7 @@ async def test_service_calls(hass: HomeAssistant) -> None:
)
assert hass.states.get("switch.decorative_lights").state == STATE_OFF
assert hass.states.get("lock.decorative_lights").state == STATE_LOCKED
assert hass.states.get("lock.decorative_lights").state == LockState.LOCKED
await hass.services.async_call(
SWITCH_DOMAIN,
@ -110,7 +108,7 @@ async def test_service_calls(hass: HomeAssistant) -> None:
)
assert hass.states.get("switch.decorative_lights").state == STATE_ON
assert hass.states.get("lock.decorative_lights").state == STATE_UNLOCKED
assert hass.states.get("lock.decorative_lights").state == LockState.UNLOCKED
await hass.services.async_call(
SWITCH_DOMAIN,
@ -120,7 +118,7 @@ async def test_service_calls(hass: HomeAssistant) -> None:
)
assert hass.states.get("switch.decorative_lights").state == STATE_OFF
assert hass.states.get("lock.decorative_lights").state == STATE_LOCKED
assert hass.states.get("lock.decorative_lights").state == LockState.LOCKED
async def test_service_calls_inverted(hass: HomeAssistant) -> None:
@ -143,7 +141,7 @@ async def test_service_calls_inverted(hass: HomeAssistant) -> None:
assert await hass.config_entries.async_setup(config_entry.entry_id)
await hass.async_block_till_done()
assert hass.states.get("lock.decorative_lights").state == STATE_LOCKED
assert hass.states.get("lock.decorative_lights").state == LockState.LOCKED
await hass.services.async_call(
LOCK_DOMAIN,
@ -153,7 +151,7 @@ async def test_service_calls_inverted(hass: HomeAssistant) -> None:
)
assert hass.states.get("switch.decorative_lights").state == STATE_ON
assert hass.states.get("lock.decorative_lights").state == STATE_LOCKED
assert hass.states.get("lock.decorative_lights").state == LockState.LOCKED
await hass.services.async_call(
LOCK_DOMAIN,
@ -163,7 +161,7 @@ async def test_service_calls_inverted(hass: HomeAssistant) -> None:
)
assert hass.states.get("switch.decorative_lights").state == STATE_OFF
assert hass.states.get("lock.decorative_lights").state == STATE_UNLOCKED
assert hass.states.get("lock.decorative_lights").state == LockState.UNLOCKED
await hass.services.async_call(
SWITCH_DOMAIN,
@ -173,7 +171,7 @@ async def test_service_calls_inverted(hass: HomeAssistant) -> None:
)
assert hass.states.get("switch.decorative_lights").state == STATE_OFF
assert hass.states.get("lock.decorative_lights").state == STATE_UNLOCKED
assert hass.states.get("lock.decorative_lights").state == LockState.UNLOCKED
await hass.services.async_call(
SWITCH_DOMAIN,
@ -183,7 +181,7 @@ async def test_service_calls_inverted(hass: HomeAssistant) -> None:
)
assert hass.states.get("switch.decorative_lights").state == STATE_ON
assert hass.states.get("lock.decorative_lights").state == STATE_LOCKED
assert hass.states.get("lock.decorative_lights").state == LockState.LOCKED
await hass.services.async_call(
SWITCH_DOMAIN,
@ -193,4 +191,4 @@ async def test_service_calls_inverted(hass: HomeAssistant) -> None:
)
assert hass.states.get("switch.decorative_lights").state == STATE_OFF
assert hass.states.get("lock.decorative_lights").state == STATE_UNLOCKED
assert hass.states.get("lock.decorative_lights").state == LockState.UNLOCKED

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

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

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

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

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

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

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

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

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

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

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 homeassistant.components.lock import LockState
from homeassistant.components.unifiprotect.const import DEFAULT_ATTRIBUTION
from homeassistant.const import (
ATTR_ATTRIBUTION,
ATTR_ENTITY_ID,
STATE_JAMMED,
STATE_LOCKED,
STATE_LOCKING,
STATE_UNAVAILABLE,
STATE_UNLOCKED,
STATE_UNLOCKING,
Platform,
)
from homeassistant.core import HomeAssistant
@ -64,7 +60,7 @@ async def test_lock_setup(
state = hass.states.get(entity_id)
assert state
assert state.state == STATE_UNLOCKED
assert state.state == LockState.UNLOCKED
assert state.attributes[ATTR_ATTRIBUTION] == DEFAULT_ATTRIBUTION
@ -92,7 +88,7 @@ async def test_lock_locked(
state = hass.states.get("lock.test_lock_lock")
assert state
assert state.state == STATE_LOCKED
assert state.state == LockState.LOCKED
async def test_lock_unlocking(
@ -119,7 +115,7 @@ async def test_lock_unlocking(
state = hass.states.get("lock.test_lock_lock")
assert state
assert state.state == STATE_UNLOCKING
assert state.state == LockState.UNLOCKING
async def test_lock_locking(
@ -146,7 +142,7 @@ async def test_lock_locking(
state = hass.states.get("lock.test_lock_lock")
assert state
assert state.state == STATE_LOCKING
assert state.state == LockState.LOCKING
async def test_lock_jammed(
@ -173,7 +169,7 @@ async def test_lock_jammed(
state = hass.states.get("lock.test_lock_lock")
assert state
assert state.state == STATE_JAMMED
assert state.state == LockState.JAMMED
async def test_lock_unavailable(

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

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

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

@ -6,7 +6,7 @@ from aiohttp import ClientResponseError
import pytest
from yalexs.exceptions import InvalidAuth, YaleApiError
from homeassistant.components.lock import DOMAIN as LOCK_DOMAIN
from homeassistant.components.lock import DOMAIN as LOCK_DOMAIN, LockState
from homeassistant.components.yale.const import DOMAIN
from homeassistant.config_entries import ConfigEntryState
from homeassistant.const import (
@ -14,7 +14,6 @@ from homeassistant.const import (
SERVICE_LOCK,
SERVICE_OPEN,
SERVICE_UNLOCK,
STATE_LOCKED,
STATE_ON,
)
from homeassistant.core import HomeAssistant
@ -151,7 +150,7 @@ async def test_inoperative_locks_are_filtered_out(hass: HomeAssistant) -> None:
lock_a6697750d607098bae8d6baa11ef8063_name = hass.states.get(
"lock.a6697750d607098bae8d6baa11ef8063_name"
)
assert lock_a6697750d607098bae8d6baa11ef8063_name.state == STATE_LOCKED
assert lock_a6697750d607098bae8d6baa11ef8063_name.state == LockState.LOCKED
async def test_lock_has_doorsense(hass: HomeAssistant) -> None:

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

@ -8,21 +8,14 @@ import pytest
from syrupy import SnapshotAssertion
from yalexs.manager.activity import INITIAL_LOCK_RESYNC_TIME
from homeassistant.components.lock import (
DOMAIN as LOCK_DOMAIN,
STATE_JAMMED,
STATE_LOCKING,
STATE_UNLOCKING,
)
from homeassistant.components.lock import DOMAIN as LOCK_DOMAIN, LockState
from homeassistant.const import (
ATTR_ENTITY_ID,
SERVICE_LOCK,
SERVICE_OPEN,
SERVICE_UNLOCK,
STATE_LOCKED,
STATE_UNAVAILABLE,
STATE_UNKNOWN,
STATE_UNLOCKED,
)
from homeassistant.core import HomeAssistant
from homeassistant.exceptions import HomeAssistantError
@ -62,7 +55,7 @@ async def test_lock_changed_by(hass: HomeAssistant) -> None:
await _create_yale_with_devices(hass, [lock_one], activities=activities)
lock_state = hass.states.get("lock.online_with_doorsense_name")
assert lock_state.state == STATE_LOCKED
assert lock_state.state == LockState.LOCKED
assert lock_state.attributes["changed_by"] == "Your favorite elven princess"
@ -73,7 +66,7 @@ async def test_state_locking(hass: HomeAssistant) -> None:
activities = await _mock_activities_from_fixture(hass, "get_activity.locking.json")
await _create_yale_with_devices(hass, [lock_one], activities=activities)
assert hass.states.get("lock.online_with_doorsense_name").state == STATE_LOCKING
assert hass.states.get("lock.online_with_doorsense_name").state == LockState.LOCKING
async def test_state_unlocking(hass: HomeAssistant) -> None:
@ -87,7 +80,7 @@ async def test_state_unlocking(hass: HomeAssistant) -> None:
lock_online_with_doorsense_name = hass.states.get("lock.online_with_doorsense_name")
assert lock_online_with_doorsense_name.state == STATE_UNLOCKING
assert lock_online_with_doorsense_name.state == LockState.UNLOCKING
async def test_state_jammed(hass: HomeAssistant) -> None:
@ -97,7 +90,7 @@ async def test_state_jammed(hass: HomeAssistant) -> None:
activities = await _mock_activities_from_fixture(hass, "get_activity.jammed.json")
await _create_yale_with_devices(hass, [lock_one], activities=activities)
assert hass.states.get("lock.online_with_doorsense_name").state == STATE_JAMMED
assert hass.states.get("lock.online_with_doorsense_name").state == LockState.JAMMED
async def test_one_lock_operation(
@ -109,7 +102,7 @@ async def test_one_lock_operation(
lock_state = hass.states.get("lock.online_with_doorsense_name")
assert lock_state.state == STATE_LOCKED
assert lock_state.state == LockState.LOCKED
assert lock_state.attributes["battery_level"] == 92
assert lock_state.attributes["friendly_name"] == "online_with_doorsense Name"
@ -118,7 +111,7 @@ async def test_one_lock_operation(
await hass.services.async_call(LOCK_DOMAIN, SERVICE_UNLOCK, data, blocking=True)
lock_state = hass.states.get("lock.online_with_doorsense_name")
assert lock_state.state == STATE_UNLOCKED
assert lock_state.state == LockState.UNLOCKED
assert lock_state.attributes["battery_level"] == 92
assert lock_state.attributes["friendly_name"] == "online_with_doorsense Name"
@ -126,7 +119,7 @@ async def test_one_lock_operation(
await hass.services.async_call(LOCK_DOMAIN, SERVICE_LOCK, data, blocking=True)
lock_state = hass.states.get("lock.online_with_doorsense_name")
assert lock_state.state == STATE_LOCKED
assert lock_state.state == LockState.LOCKED
# No activity means it will be unavailable until the activity feed has data
assert entity_registry.async_get("sensor.online_with_doorsense_name_operator")
@ -139,12 +132,12 @@ async def test_open_lock_operation(hass: HomeAssistant) -> None:
lock_with_unlatch = await _mock_lock_with_unlatch(hass)
await _create_yale_with_devices(hass, [lock_with_unlatch])
assert hass.states.get("lock.online_with_unlatch_name").state == STATE_LOCKED
assert hass.states.get("lock.online_with_unlatch_name").state == LockState.LOCKED
data = {ATTR_ENTITY_ID: "lock.online_with_unlatch_name"}
await hass.services.async_call(LOCK_DOMAIN, SERVICE_OPEN, data, blocking=True)
assert hass.states.get("lock.online_with_unlatch_name").state == STATE_UNLOCKED
assert hass.states.get("lock.online_with_unlatch_name").state == LockState.UNLOCKED
async def test_open_lock_operation_socketio_connected(
@ -159,7 +152,7 @@ async def test_open_lock_operation_socketio_connected(
_, socketio = await _create_yale_with_devices(hass, [lock_with_unlatch])
socketio.connected = True
assert hass.states.get("lock.online_with_unlatch_name").state == STATE_LOCKED
assert hass.states.get("lock.online_with_unlatch_name").state == LockState.LOCKED
data = {ATTR_ENTITY_ID: "lock.online_with_unlatch_name"}
await hass.services.async_call(LOCK_DOMAIN, SERVICE_OPEN, data, blocking=True)
@ -176,7 +169,7 @@ async def test_open_lock_operation_socketio_connected(
await hass.async_block_till_done()
await hass.async_block_till_done()
assert hass.states.get("lock.online_with_unlatch_name").state == STATE_UNLOCKED
assert hass.states.get("lock.online_with_unlatch_name").state == LockState.UNLOCKED
await hass.async_block_till_done()
@ -194,7 +187,7 @@ async def test_one_lock_operation_socketio_connected(
socketio.connected = True
lock_state = hass.states.get("lock.online_with_doorsense_name")
assert lock_state.state == STATE_LOCKED
assert lock_state.state == LockState.LOCKED
assert lock_state.attributes["battery_level"] == 92
assert lock_state.attributes["friendly_name"] == "online_with_doorsense Name"
@ -214,7 +207,7 @@ async def test_one_lock_operation_socketio_connected(
await hass.async_block_till_done()
lock_state = states.get("lock.online_with_doorsense_name")
assert lock_state.state == STATE_UNLOCKED
assert lock_state.state == LockState.UNLOCKED
assert lock_state.attributes["battery_level"] == 92
assert lock_state.attributes["friendly_name"] == "online_with_doorsense Name"
@ -231,7 +224,7 @@ async def test_one_lock_operation_socketio_connected(
await hass.async_block_till_done()
await hass.async_block_till_done()
assert states.get("lock.online_with_doorsense_name").state == STATE_LOCKED
assert states.get("lock.online_with_doorsense_name").state == LockState.LOCKED
# No activity means it will be unavailable until the activity feed has data
assert entity_registry.async_get("sensor.online_with_doorsense_name_operator")
@ -251,7 +244,7 @@ async def test_one_lock_operation_socketio_connected(
await hass.async_block_till_done()
assert states.get("lock.online_with_doorsense_name").state == STATE_UNLOCKED
assert states.get("lock.online_with_doorsense_name").state == LockState.UNLOCKED
async def test_lock_jammed(hass: HomeAssistant) -> None:
@ -271,14 +264,14 @@ async def test_lock_jammed(hass: HomeAssistant) -> None:
states = hass.states
lock_state = states.get("lock.online_with_doorsense_name")
assert lock_state.state == STATE_LOCKED
assert lock_state.state == LockState.LOCKED
assert lock_state.attributes["battery_level"] == 92
assert lock_state.attributes["friendly_name"] == "online_with_doorsense Name"
data = {ATTR_ENTITY_ID: "lock.online_with_doorsense_name"}
await hass.services.async_call(LOCK_DOMAIN, SERVICE_UNLOCK, data, blocking=True)
assert states.get("lock.online_with_doorsense_name").state == STATE_JAMMED
assert states.get("lock.online_with_doorsense_name").state == LockState.JAMMED
async def test_lock_throws_exception_on_unknown_status_code(
@ -299,7 +292,7 @@ async def test_lock_throws_exception_on_unknown_status_code(
)
lock_state = hass.states.get("lock.online_with_doorsense_name")
assert lock_state.state == STATE_LOCKED
assert lock_state.state == LockState.LOCKED
assert lock_state.attributes["battery_level"] == 92
assert lock_state.attributes["friendly_name"] == "online_with_doorsense Name"
@ -342,7 +335,7 @@ async def test_lock_bridge_online(hass: HomeAssistant) -> None:
await _create_yale_with_devices(hass, [lock_one], activities=activities)
states = hass.states
assert states.get("lock.online_with_doorsense_name").state == STATE_LOCKED
assert states.get("lock.online_with_doorsense_name").state == LockState.LOCKED
async def test_lock_update_via_socketio(hass: HomeAssistant) -> None:
@ -357,7 +350,7 @@ async def test_lock_update_via_socketio(hass: HomeAssistant) -> None:
socketio.connected = True
states = hass.states
assert states.get("lock.online_with_doorsense_name").state == STATE_LOCKED
assert states.get("lock.online_with_doorsense_name").state == LockState.LOCKED
listener = list(socketio._listeners)[0]
listener(
@ -371,7 +364,7 @@ async def test_lock_update_via_socketio(hass: HomeAssistant) -> None:
await hass.async_block_till_done()
await hass.async_block_till_done()
assert states.get("lock.online_with_doorsense_name").state == STATE_UNLOCKING
assert states.get("lock.online_with_doorsense_name").state == LockState.UNLOCKING
listener(
lock_one.device_id,
@ -384,21 +377,21 @@ async def test_lock_update_via_socketio(hass: HomeAssistant) -> None:
await hass.async_block_till_done()
await hass.async_block_till_done()
assert states.get("lock.online_with_doorsense_name").state == STATE_LOCKING
assert states.get("lock.online_with_doorsense_name").state == LockState.LOCKING
async_fire_time_changed(hass, dt_util.utcnow() + datetime.timedelta(seconds=30))
await hass.async_block_till_done()
assert states.get("lock.online_with_doorsense_name").state == STATE_LOCKING
assert states.get("lock.online_with_doorsense_name").state == LockState.LOCKING
socketio.connected = True
async_fire_time_changed(hass, dt_util.utcnow() + datetime.timedelta(seconds=30))
await hass.async_block_till_done()
assert states.get("lock.online_with_doorsense_name").state == STATE_LOCKING
assert states.get("lock.online_with_doorsense_name").state == LockState.LOCKING
# Ensure socketio status is always preserved
async_fire_time_changed(hass, dt_util.utcnow() + datetime.timedelta(hours=2))
await hass.async_block_till_done()
assert states.get("lock.online_with_doorsense_name").state == STATE_LOCKING
assert states.get("lock.online_with_doorsense_name").state == LockState.LOCKING
listener(
lock_one.device_id,
@ -411,11 +404,11 @@ async def test_lock_update_via_socketio(hass: HomeAssistant) -> None:
await hass.async_block_till_done()
await hass.async_block_till_done()
assert states.get("lock.online_with_doorsense_name").state == STATE_UNLOCKING
assert states.get("lock.online_with_doorsense_name").state == LockState.UNLOCKING
async_fire_time_changed(hass, dt_util.utcnow() + datetime.timedelta(hours=4))
await hass.async_block_till_done()
assert states.get("lock.online_with_doorsense_name").state == STATE_UNLOCKING
assert states.get("lock.online_with_doorsense_name").state == LockState.UNLOCKING
await hass.config_entries.async_unload(config_entry.entry_id)
await hass.async_block_till_done()

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

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

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

13
tests/helpers/test_state.py
View File

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

32
tests/test_const.py
View File

@ -5,7 +5,7 @@ from enum import Enum
import pytest
from homeassistant import const
from homeassistant.components import sensor
from homeassistant.components import lock, sensor
from .common import (
help_test_all,
@ -182,3 +182,33 @@ def test_deprecated_constant_name_changes(
replacement,
"2025.1",
)
def _create_tuples_lock_states(
enum: type[Enum], constant_prefix: str, remove_in_version: str
) -> list[tuple[Enum, str]]:
return [
(enum_field, constant_prefix, remove_in_version)
for enum_field in enum
if enum_field
not in [
lock.LockState.OPEN,
lock.LockState.OPENING,
]
]
@pytest.mark.parametrize(
("enum", "constant_prefix", "remove_in_version"),
_create_tuples_lock_states(lock.LockState, "STATE_", "2025.10"),
)
def test_deprecated_constants_lock(
caplog: pytest.LogCaptureFixture,
enum: Enum,
constant_prefix: str,
remove_in_version: str,
) -> None:
"""Test deprecated constants."""
import_and_test_deprecated_constant_enum(
caplog, const, enum, constant_prefix, remove_in_version
)