Home-Assistant
/
core
mirror of https://github.com/home-assistant/core.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Address yale review comments part 2 (#124887) 

* Remove some unneeded block till done

* Additional state check cleanups and snapshots

* Use more snapshots in yale tests
pull/124911/head
J. Nick Koston 2024-08-29 21:37:19 -10:00 committed by GitHub
parent cf90e77e57
commit df60e59a95
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
5 changed files with 226 additions and 206 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

37
tests/components/yale/snapshots/test_lock.ambr Normal file
View File

@ -0,0 +1,37 @@
# serializer version: 1
# name: test_lock_device_registry
DeviceRegistryEntrySnapshot({
'area_id': 'online_with_doorsense_name',
'config_entries': <ANY>,
'configuration_url': 'https://account.aaecosystem.com',
'connections': set({
tuple(
'bluetooth',
'12:22',
),
}),
'disabled_by': None,
'entry_type': None,
'hw_version': None,
'id': <ANY>,
'identifiers': set({
tuple(
'yale',
'online_with_doorsense',
),
}),
'is_new': False,
'labels': set({
}),
'manufacturer': 'Yale Home Inc.',
'model': 'AUG-MD01',
'model_id': None,
'name': 'online_with_doorsense Name',
'name_by_user': None,
'primary_config_entry': <ANY>,
'serial_number': None,
'suggested_area': 'online_with_doorsense Name',
'sw_version': 'undefined-4.3.0-1.8.14',
'via_device_id': None,
})
# ---

95
tests/components/yale/snapshots/test_sensor.ambr Normal file
View File

@ -0,0 +1,95 @@
# serializer version: 1
# name: test_lock_operator_autorelock
ReadOnlyDict({
'autorelock': True,
'friendly_name': 'online_with_doorsense Name Operator',
'keypad': False,
'manual': False,
'method': 'autorelock',
'remote': False,
'tag': False,
})
# ---
# name: test_lock_operator_keypad
ReadOnlyDict({
'autorelock': False,
'friendly_name': 'online_with_doorsense Name Operator',
'keypad': True,
'manual': False,
'method': 'keypad',
'remote': False,
'tag': False,
})
# ---
# name: test_lock_operator_manual
ReadOnlyDict({
'autorelock': False,
'friendly_name': 'online_with_doorsense Name Operator',
'keypad': False,
'manual': True,
'method': 'manual',
'remote': False,
'tag': False,
})
# ---
# name: test_lock_operator_remote
ReadOnlyDict({
'autorelock': False,
'friendly_name': 'online_with_doorsense Name Operator',
'keypad': False,
'manual': False,
'method': 'remote',
'remote': True,
'tag': False,
})
# ---
# name: test_restored_state
StateSnapshot({
'attributes': ReadOnlyDict({
'autorelock': False,
'entity_picture': 'image.png',
'friendly_name': 'online_with_doorsense Name Operator',
'keypad': False,
'manual': False,
'method': 'tag',
'remote': False,
'tag': True,
}),
'context': <ANY>,
'entity_id': 'sensor.online_with_doorsense_name_operator',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': 'Tag Unlock',
})
# ---
# name: test_unlock_operator_manual
StateSnapshot({
'attributes': ReadOnlyDict({
'autorelock': False,
'friendly_name': 'online_with_doorsense Name Operator',
'keypad': False,
'manual': True,
'method': 'manual',
'remote': False,
'tag': False,
}),
'context': <ANY>,
'entity_id': 'sensor.online_with_doorsense_name_operator',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': 'Your favorite elven princess',
})
# ---
# name: test_unlock_operator_tag
ReadOnlyDict({
'autorelock': False,
'friendly_name': 'online_with_doorsense Name Operator',
'keypad': False,
'manual': False,
'method': 'tag',
'remote': False,
'tag': True,
})
# ---

1
tests/components/yale/test_button.py
View File

@ -20,5 +20,4 @@ async def test_wake_lock(hass: HomeAssistant) -> None:
await hass.services.async_call(
BUTTON_DOMAIN, SERVICE_PRESS, {ATTR_ENTITY_ID: entity_id}, blocking=True
)
await hass.async_block_till_done()
api_instance.async_status_async.assert_called_once()

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

@ -5,6 +5,7 @@ import datetime
from aiohttp import ClientResponseError
from freezegun.api import FrozenDateTimeFactory
import pytest
from syrupy import SnapshotAssertion
from yalexs.manager.activity import INITIAL_LOCK_RESYNC_TIME
from homeassistant.components.lock import (
@ -41,7 +42,7 @@ from tests.common import async_fire_time_changed
async def test_lock_device_registry(
hass: HomeAssistant, device_registry: dr.DeviceRegistry
hass: HomeAssistant, device_registry: dr.DeviceRegistry, snapshot: SnapshotAssertion
) -> None:
"""Test creation of a lock with doorsense and bridge ands up in the registry."""
lock_one = await _mock_doorsense_enabled_yale_lock_detail(hass)
@ -50,10 +51,7 @@ async def test_lock_device_registry(
reg_device = device_registry.async_get_device(
identifiers={("yale", "online_with_doorsense")}
)
assert reg_device.model == "AUG-MD01"
assert reg_device.sw_version == "undefined-4.3.0-1.8.14"
assert reg_device.name == "online_with_doorsense Name"
assert reg_device.manufacturer == "Yale Home Inc."
assert reg_device == snapshot
async def test_lock_changed_by(hass: HomeAssistant) -> None:
@ -63,14 +61,9 @@ async def test_lock_changed_by(hass: HomeAssistant) -> None:
activities = await _mock_activities_from_fixture(hass, "get_activity.lock.json")
await _create_yale_with_devices(hass, [lock_one], activities=activities)
lock_online_with_doorsense_name = hass.states.get("lock.online_with_doorsense_name")
assert lock_online_with_doorsense_name.state == STATE_LOCKED
assert (
lock_online_with_doorsense_name.attributes.get("changed_by")
== "Your favorite elven princess"
)
lock_state = hass.states.get("lock.online_with_doorsense_name")
assert lock_state.state == STATE_LOCKED
assert lock_state.attributes["changed_by"] == "Your favorite elven princess"
async def test_state_locking(hass: HomeAssistant) -> None:
@ -80,9 +73,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)
lock_online_with_doorsense_name = hass.states.get("lock.online_with_doorsense_name")
assert lock_online_with_doorsense_name.state == STATE_LOCKING
assert hass.states.get("lock.online_with_doorsense_name").state == STATE_LOCKING
async def test_state_unlocking(hass: HomeAssistant) -> None:
@ -106,9 +97,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)
lock_online_with_doorsense_name = hass.states.get("lock.online_with_doorsense_name")
assert lock_online_with_doorsense_name.state == STATE_JAMMED
assert hass.states.get("lock.online_with_doorsense_name").state == STATE_JAMMED
async def test_one_lock_operation(
@ -118,44 +107,31 @@ async def test_one_lock_operation(
lock_one = await _mock_doorsense_enabled_yale_lock_detail(hass)
await _create_yale_with_devices(hass, [lock_one])
lock_online_with_doorsense_name = hass.states.get("lock.online_with_doorsense_name")
lock_state = hass.states.get("lock.online_with_doorsense_name")
assert lock_online_with_doorsense_name.state == STATE_LOCKED
assert lock_state.state == STATE_LOCKED
assert lock_online_with_doorsense_name.attributes.get("battery_level") == 92
assert (
lock_online_with_doorsense_name.attributes.get("friendly_name")
== "online_with_doorsense Name"
)
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)
await hass.async_block_till_done()
lock_online_with_doorsense_name = hass.states.get("lock.online_with_doorsense_name")
assert lock_online_with_doorsense_name.state == STATE_UNLOCKED
lock_state = hass.states.get("lock.online_with_doorsense_name")
assert lock_state.state == STATE_UNLOCKED
assert lock_online_with_doorsense_name.attributes.get("battery_level") == 92
assert (
lock_online_with_doorsense_name.attributes.get("friendly_name")
== "online_with_doorsense Name"
)
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)
await hass.async_block_till_done()
lock_online_with_doorsense_name = hass.states.get("lock.online_with_doorsense_name")
assert lock_online_with_doorsense_name.state == STATE_LOCKED
lock_state = hass.states.get("lock.online_with_doorsense_name")
assert lock_state.state == STATE_LOCKED
# No activity means it will be unavailable until the activity feed has data
lock_operator_sensor = entity_registry.async_get(
"sensor.online_with_doorsense_name_operator"
)
assert lock_operator_sensor
assert (
hass.states.get("sensor.online_with_doorsense_name_operator").state
== STATE_UNKNOWN
)
assert entity_registry.async_get("sensor.online_with_doorsense_name_operator")
operator_state = hass.states.get("sensor.online_with_doorsense_name_operator")
assert operator_state.state == STATE_UNKNOWN
async def test_open_lock_operation(hass: HomeAssistant) -> None:
@ -163,15 +139,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])
lock_online_with_unlatch_name = hass.states.get("lock.online_with_unlatch_name")
assert lock_online_with_unlatch_name.state == STATE_LOCKED
assert hass.states.get("lock.online_with_unlatch_name").state == STATE_LOCKED
data = {ATTR_ENTITY_ID: "lock.online_with_unlatch_name"}
await hass.services.async_call(LOCK_DOMAIN, SERVICE_OPEN, data, blocking=True)
await hass.async_block_till_done()
lock_online_with_unlatch_name = hass.states.get("lock.online_with_unlatch_name")
assert lock_online_with_unlatch_name.state == STATE_UNLOCKED
assert hass.states.get("lock.online_with_unlatch_name").state == STATE_UNLOCKED
async def test_open_lock_operation_socketio_connected(
@ -186,12 +159,10 @@ async def test_open_lock_operation_socketio_connected(
_, socketio = await _create_yale_with_devices(hass, [lock_with_unlatch])
socketio.connected = True
lock_online_with_unlatch_name = hass.states.get("lock.online_with_unlatch_name")
assert lock_online_with_unlatch_name.state == STATE_LOCKED
assert hass.states.get("lock.online_with_unlatch_name").state == STATE_LOCKED
data = {ATTR_ENTITY_ID: "lock.online_with_unlatch_name"}
await hass.services.async_call(LOCK_DOMAIN, SERVICE_OPEN, data, blocking=True)
await hass.async_block_till_done()
listener = list(socketio._listeners)[0]
listener(
@ -205,8 +176,7 @@ async def test_open_lock_operation_socketio_connected(
await hass.async_block_till_done()
await hass.async_block_till_done()
lock_online_with_unlatch_name = hass.states.get("lock.online_with_unlatch_name")
assert lock_online_with_unlatch_name.state == STATE_UNLOCKED
assert hass.states.get("lock.online_with_unlatch_name").state == STATE_UNLOCKED
await hass.async_block_till_done()
@ -218,23 +188,18 @@ async def test_one_lock_operation_socketio_connected(
"""Test lock and unlock operations are async when socketio is connected."""
lock_one = await _mock_doorsense_enabled_yale_lock_detail(hass)
assert lock_one.pubsub_channel == "pubsub"
states = hass.states
_, socketio = await _create_yale_with_devices(hass, [lock_one])
socketio.connected = True
lock_online_with_doorsense_name = hass.states.get("lock.online_with_doorsense_name")
assert lock_online_with_doorsense_name.state == STATE_LOCKED
assert lock_online_with_doorsense_name.attributes.get("battery_level") == 92
assert (
lock_online_with_doorsense_name.attributes.get("friendly_name")
== "online_with_doorsense Name"
)
lock_state = hass.states.get("lock.online_with_doorsense_name")
assert lock_state.state == STATE_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)
await hass.async_block_till_done()
listener = list(socketio._listeners)[0]
listener(
@ -248,17 +213,12 @@ async def test_one_lock_operation_socketio_connected(
await hass.async_block_till_done()
await hass.async_block_till_done()
lock_online_with_doorsense_name = hass.states.get("lock.online_with_doorsense_name")
assert lock_online_with_doorsense_name.state == STATE_UNLOCKED
assert lock_online_with_doorsense_name.attributes.get("battery_level") == 92
assert (
lock_online_with_doorsense_name.attributes.get("friendly_name")
== "online_with_doorsense Name"
)
lock_state = states.get("lock.online_with_doorsense_name")
assert lock_state.state == STATE_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)
await hass.async_block_till_done()
listener(
lock_one.device_id,
@ -271,17 +231,12 @@ async def test_one_lock_operation_socketio_connected(
await hass.async_block_till_done()
await hass.async_block_till_done()
lock_online_with_doorsense_name = hass.states.get("lock.online_with_doorsense_name")
assert lock_online_with_doorsense_name.state == STATE_LOCKED
assert states.get("lock.online_with_doorsense_name").state == STATE_LOCKED
# No activity means it will be unavailable until the activity feed has data
lock_operator_sensor = entity_registry.async_get(
"sensor.online_with_doorsense_name_operator"
)
assert lock_operator_sensor
assert entity_registry.async_get("sensor.online_with_doorsense_name_operator")
assert (
hass.states.get("sensor.online_with_doorsense_name_operator").state
== STATE_UNKNOWN
states.get("sensor.online_with_doorsense_name_operator").state == STATE_UNKNOWN
)
freezer.tick(INITIAL_LOCK_RESYNC_TIME)
@ -296,8 +251,7 @@ async def test_one_lock_operation_socketio_connected(
await hass.async_block_till_done()
lock_online_with_doorsense_name = hass.states.get("lock.online_with_doorsense_name")
assert lock_online_with_doorsense_name.state == STATE_UNLOCKED
assert states.get("lock.online_with_doorsense_name").state == STATE_UNLOCKED
async def test_lock_jammed(hass: HomeAssistant) -> None:
@ -315,22 +269,16 @@ async def test_lock_jammed(hass: HomeAssistant) -> None:
},
)
lock_online_with_doorsense_name = hass.states.get("lock.online_with_doorsense_name")
assert lock_online_with_doorsense_name.state == STATE_LOCKED
assert lock_online_with_doorsense_name.attributes.get("battery_level") == 92
assert (
lock_online_with_doorsense_name.attributes.get("friendly_name")
== "online_with_doorsense Name"
)
states = hass.states
lock_state = states.get("lock.online_with_doorsense_name")
assert lock_state.state == STATE_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)
await hass.async_block_till_done()
lock_online_with_doorsense_name = hass.states.get("lock.online_with_doorsense_name")
assert lock_online_with_doorsense_name.state == STATE_JAMMED
assert states.get("lock.online_with_doorsense_name").state == STATE_JAMMED
async def test_lock_throws_exception_on_unknown_status_code(
@ -350,15 +298,10 @@ async def test_lock_throws_exception_on_unknown_status_code(
},
)
lock_online_with_doorsense_name = hass.states.get("lock.online_with_doorsense_name")
assert lock_online_with_doorsense_name.state == STATE_LOCKED
assert lock_online_with_doorsense_name.attributes.get("battery_level") == 92
assert (
lock_online_with_doorsense_name.attributes.get("friendly_name")
== "online_with_doorsense Name"
)
lock_state = hass.states.get("lock.online_with_doorsense_name")
assert lock_state.state == STATE_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"}
with pytest.raises(ClientResponseError):
@ -373,9 +316,7 @@ async def test_one_lock_unknown_state(hass: HomeAssistant) -> None:
)
await _create_yale_with_devices(hass, [lock_one])
lock_brokenid_name = hass.states.get("lock.brokenid_name")
assert lock_brokenid_name.state == STATE_UNKNOWN
assert hass.states.get("lock.brokenid_name").state == STATE_UNKNOWN
async def test_lock_bridge_offline(hass: HomeAssistant) -> None:
@ -387,9 +328,8 @@ async def test_lock_bridge_offline(hass: HomeAssistant) -> None:
)
await _create_yale_with_devices(hass, [lock_one], activities=activities)
lock_online_with_doorsense_name = hass.states.get("lock.online_with_doorsense_name")
assert lock_online_with_doorsense_name.state == STATE_UNAVAILABLE
states = hass.states
assert states.get("lock.online_with_doorsense_name").state == STATE_UNAVAILABLE
async def test_lock_bridge_online(hass: HomeAssistant) -> None:
@ -401,9 +341,8 @@ async def test_lock_bridge_online(hass: HomeAssistant) -> None:
)
await _create_yale_with_devices(hass, [lock_one], activities=activities)
lock_online_with_doorsense_name = hass.states.get("lock.online_with_doorsense_name")
assert lock_online_with_doorsense_name.state == STATE_LOCKED
states = hass.states
assert states.get("lock.online_with_doorsense_name").state == STATE_LOCKED
async def test_lock_update_via_socketio(hass: HomeAssistant) -> None:
@ -416,10 +355,9 @@ async def test_lock_update_via_socketio(hass: HomeAssistant) -> None:
hass, [lock_one], activities=activities
)
socketio.connected = True
states = hass.states
lock_online_with_doorsense_name = hass.states.get("lock.online_with_doorsense_name")
assert lock_online_with_doorsense_name.state == STATE_LOCKED
assert states.get("lock.online_with_doorsense_name").state == STATE_LOCKED
listener = list(socketio._listeners)[0]
listener(
@ -433,8 +371,7 @@ async def test_lock_update_via_socketio(hass: HomeAssistant) -> None:
await hass.async_block_till_done()
await hass.async_block_till_done()
lock_online_with_doorsense_name = hass.states.get("lock.online_with_doorsense_name")
assert lock_online_with_doorsense_name.state == STATE_UNLOCKING
assert states.get("lock.online_with_doorsense_name").state == STATE_UNLOCKING
listener(
lock_one.device_id,
@ -447,25 +384,21 @@ async def test_lock_update_via_socketio(hass: HomeAssistant) -> None:
await hass.async_block_till_done()
await hass.async_block_till_done()
lock_online_with_doorsense_name = hass.states.get("lock.online_with_doorsense_name")
assert lock_online_with_doorsense_name.state == STATE_LOCKING
assert states.get("lock.online_with_doorsense_name").state == STATE_LOCKING
async_fire_time_changed(hass, dt_util.utcnow() + datetime.timedelta(seconds=30))
await hass.async_block_till_done()
lock_online_with_doorsense_name = hass.states.get("lock.online_with_doorsense_name")
assert lock_online_with_doorsense_name.state == STATE_LOCKING
assert states.get("lock.online_with_doorsense_name").state == STATE_LOCKING
socketio.connected = True
async_fire_time_changed(hass, dt_util.utcnow() + datetime.timedelta(seconds=30))
await hass.async_block_till_done()
lock_online_with_doorsense_name = hass.states.get("lock.online_with_doorsense_name")
assert lock_online_with_doorsense_name.state == STATE_LOCKING
assert states.get("lock.online_with_doorsense_name").state == STATE_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()
lock_online_with_doorsense_name = hass.states.get("lock.online_with_doorsense_name")
assert lock_online_with_doorsense_name.state == STATE_LOCKING
assert states.get("lock.online_with_doorsense_name").state == STATE_LOCKING
listener(
lock_one.device_id,
@ -478,13 +411,11 @@ async def test_lock_update_via_socketio(hass: HomeAssistant) -> None:
await hass.async_block_till_done()
await hass.async_block_till_done()
lock_online_with_doorsense_name = hass.states.get("lock.online_with_doorsense_name")
assert lock_online_with_doorsense_name.state == STATE_UNLOCKING
assert states.get("lock.online_with_doorsense_name").state == STATE_UNLOCKING
async_fire_time_changed(hass, dt_util.utcnow() + datetime.timedelta(hours=4))
await hass.async_block_till_done()
lock_online_with_doorsense_name = hass.states.get("lock.online_with_doorsense_name")
assert lock_online_with_doorsense_name.state == STATE_UNLOCKING
assert states.get("lock.online_with_doorsense_name").state == STATE_UNLOCKING
await hass.config_entries.async_unload(config_entry.entry_id)
await hass.async_block_till_done()

106
tests/components/yale/test_sensor.py
View File

@ -2,6 +2,8 @@
from typing import Any
from syrupy import SnapshotAssertion
from homeassistant import core as ha
from homeassistant.const import (
ATTR_ENTITY_PICTURE,
@ -28,13 +30,9 @@ async def test_create_doorbell(hass: HomeAssistant) -> None:
doorbell_one = await _mock_doorbell_from_fixture(hass, "get_doorbell.json")
await _create_yale_with_devices(hass, [doorbell_one])
sensor_k98gidt45gul_name_battery = hass.states.get(
"sensor.k98gidt45gul_name_battery"
)
assert sensor_k98gidt45gul_name_battery.state == "96"
assert (
sensor_k98gidt45gul_name_battery.attributes["unit_of_measurement"] == PERCENTAGE
)
battery_state = hass.states.get("sensor.k98gidt45gul_name_battery")
assert battery_state.state == "96"
assert battery_state.attributes["unit_of_measurement"] == PERCENTAGE
async def test_create_doorbell_offline(
@ -44,9 +42,9 @@ async def test_create_doorbell_offline(
doorbell_one = await _mock_doorbell_from_fixture(hass, "get_doorbell.offline.json")
await _create_yale_with_devices(hass, [doorbell_one])
sensor_tmt100_name_battery = hass.states.get("sensor.tmt100_name_battery")
assert sensor_tmt100_name_battery.state == "81"
assert sensor_tmt100_name_battery.attributes["unit_of_measurement"] == PERCENTAGE
battery_state = hass.states.get("sensor.tmt100_name_battery")
assert battery_state.state == "81"
assert battery_state.attributes["unit_of_measurement"] == PERCENTAGE
entry = entity_registry.async_get("sensor.tmt100_name_battery")
assert entry
@ -71,25 +69,21 @@ async def test_create_lock_with_linked_keypad(
lock_one = await _mock_lock_from_fixture(hass, "get_lock.doorsense_init.json")
await _create_yale_with_devices(hass, [lock_one])
sensor_a6697750d607098bae8d6baa11ef8063_name_battery = hass.states.get(
battery_state = hass.states.get(
"sensor.a6697750d607098bae8d6baa11ef8063_name_battery"
)
assert sensor_a6697750d607098bae8d6baa11ef8063_name_battery.state == "88"
assert (
sensor_a6697750d607098bae8d6baa11ef8063_name_battery.attributes[
"unit_of_measurement"
]
== PERCENTAGE
)
assert battery_state.state == "88"
assert battery_state.attributes["unit_of_measurement"] == PERCENTAGE
entry = entity_registry.async_get(
"sensor.a6697750d607098bae8d6baa11ef8063_name_battery"
)
assert entry
assert entry.unique_id == "A6697750D607098BAE8D6BAA11EF8063_device_battery"
state = hass.states.get("sensor.front_door_lock_keypad_battery")
assert state.state == "62"
assert state.attributes[ATTR_UNIT_OF_MEASUREMENT] == PERCENTAGE
keypad_battery_state = hass.states.get("sensor.front_door_lock_keypad_battery")
assert keypad_battery_state.state == "62"
assert keypad_battery_state.attributes[ATTR_UNIT_OF_MEASUREMENT] == PERCENTAGE
entry = entity_registry.async_get("sensor.front_door_lock_keypad_battery")
assert entry
assert entry.unique_id == "5bc65c24e6ef2a263e1450a8_linked_keypad_battery"
@ -102,16 +96,11 @@ async def test_create_lock_with_low_battery_linked_keypad(
lock_one = await _mock_lock_from_fixture(hass, "get_lock.low_keypad_battery.json")
await _create_yale_with_devices(hass, [lock_one])
sensor_a6697750d607098bae8d6baa11ef8063_name_battery = hass.states.get(
battery_state = hass.states.get(
"sensor.a6697750d607098bae8d6baa11ef8063_name_battery"
)
assert sensor_a6697750d607098bae8d6baa11ef8063_name_battery.state == "88"
assert (
sensor_a6697750d607098bae8d6baa11ef8063_name_battery.attributes[
"unit_of_measurement"
]
== PERCENTAGE
)
assert battery_state.state == "88"
assert battery_state.attributes["unit_of_measurement"] == PERCENTAGE
entry = entity_registry.async_get(
"sensor.a6697750d607098bae8d6baa11ef8063_name_battery"
)
@ -166,7 +155,7 @@ async def test_lock_operator_bluetooth(
async def test_lock_operator_keypad(
hass: HomeAssistant, entity_registry: er.EntityRegistry
hass: HomeAssistant, entity_registry: er.EntityRegistry, snapshot: SnapshotAssertion
) -> None:
"""Test operation of a lock with doorsense and bridge."""
lock_one = await _mock_doorsense_enabled_yale_lock_detail(hass)
@ -183,16 +172,11 @@ async def test_lock_operator_keypad(
state = hass.states.get("sensor.online_with_doorsense_name_operator")
assert state.state == "Your favorite elven princess"
assert state.attributes["manual"] is False
assert state.attributes["tag"] is False
assert state.attributes["remote"] is False
assert state.attributes["keypad"] is True
assert state.attributes["autorelock"] is False
assert state.attributes["method"] == "keypad"
assert state.attributes == snapshot
async def test_lock_operator_remote(
hass: HomeAssistant, entity_registry: er.EntityRegistry
hass: HomeAssistant, entity_registry: er.EntityRegistry, snapshot: SnapshotAssertion
) -> None:
"""Test operation of a lock with doorsense and bridge."""
lock_one = await _mock_doorsense_enabled_yale_lock_detail(hass)
@ -207,16 +191,11 @@ async def test_lock_operator_remote(
state = hass.states.get("sensor.online_with_doorsense_name_operator")
assert state.state == "Your favorite elven princess"
assert state.attributes["manual"] is False
assert state.attributes["tag"] is False
assert state.attributes["remote"] is True
assert state.attributes["keypad"] is False
assert state.attributes["autorelock"] is False
assert state.attributes["method"] == "remote"
assert state.attributes == snapshot
async def test_lock_operator_manual(
hass: HomeAssistant, entity_registry: er.EntityRegistry
hass: HomeAssistant, entity_registry: er.EntityRegistry, snapshot: SnapshotAssertion
) -> None:
"""Test operation of a lock with doorsense and bridge."""
lock_one = await _mock_doorsense_enabled_yale_lock_detail(hass)
@ -232,16 +211,11 @@ async def test_lock_operator_manual(
assert lock_operator_sensor
state = hass.states.get("sensor.online_with_doorsense_name_operator")
assert state.state == "Your favorite elven princess"
assert state.attributes["manual"] is True
assert state.attributes["tag"] is False
assert state.attributes["remote"] is False
assert state.attributes["keypad"] is False
assert state.attributes["autorelock"] is False
assert state.attributes["method"] == "manual"
assert state.attributes == snapshot
async def test_lock_operator_autorelock(
hass: HomeAssistant, entity_registry: er.EntityRegistry
hass: HomeAssistant, entity_registry: er.EntityRegistry, snapshot: SnapshotAssertion
) -> None:
"""Test operation of a lock with doorsense and bridge."""
lock_one = await _mock_doorsense_enabled_yale_lock_detail(hass)
@ -258,16 +232,11 @@ async def test_lock_operator_autorelock(
state = hass.states.get("sensor.online_with_doorsense_name_operator")
assert state.state == "Auto Relock"
assert state.attributes["manual"] is False
assert state.attributes["tag"] is False
assert state.attributes["remote"] is False
assert state.attributes["keypad"] is False
assert state.attributes["autorelock"] is True
assert state.attributes["method"] == "autorelock"
assert state.attributes == snapshot
async def test_unlock_operator_manual(
hass: HomeAssistant, entity_registry: er.EntityRegistry
hass: HomeAssistant, entity_registry: er.EntityRegistry, snapshot: SnapshotAssertion
) -> None:
"""Test operation of a lock manually."""
lock_one = await _mock_doorsense_enabled_yale_lock_detail(hass)
@ -284,16 +253,11 @@ async def test_unlock_operator_manual(
state = hass.states.get("sensor.online_with_doorsense_name_operator")
assert state.state == "Your favorite elven princess"
assert state.attributes["manual"] is True
assert state.attributes["tag"] is False
assert state.attributes["remote"] is False
assert state.attributes["keypad"] is False
assert state.attributes["autorelock"] is False
assert state.attributes["method"] == "manual"
assert state == snapshot
async def test_unlock_operator_tag(
hass: HomeAssistant, entity_registry: er.EntityRegistry
hass: HomeAssistant, entity_registry: er.EntityRegistry, snapshot: SnapshotAssertion
) -> None:
"""Test operation of a lock with a tag."""
lock_one = await _mock_doorsense_enabled_yale_lock_detail(hass)
@ -310,16 +274,11 @@ async def test_unlock_operator_tag(
state = hass.states.get("sensor.online_with_doorsense_name_operator")
assert state.state == "Your favorite elven princess"
assert state.attributes["manual"] is False
assert state.attributes["tag"] is True
assert state.attributes["remote"] is False
assert state.attributes["keypad"] is False
assert state.attributes["autorelock"] is False
assert state.attributes["method"] == "tag"
assert state.attributes == snapshot
async def test_restored_state(
hass: HomeAssistant, hass_storage: dict[str, Any]
hass: HomeAssistant, hass_storage: dict[str, Any], snapshot: SnapshotAssertion
) -> None:
"""Test restored state."""
@ -358,5 +317,4 @@ async def test_restored_state(
state = hass.states.get(entity_id)
assert state.state == "Tag Unlock"
assert state.attributes["method"] == "tag"
assert state.attributes[ATTR_ENTITY_PICTURE] == "image.png"
assert state == snapshot