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

Address august review comments (#124819) 

* Address august review comments

Followup to https://github.com/home-assistant/core/pull/124677

* cleanup loop

* drop mixin name

* event entity add cleanup

* remove duplicate prop

* pep0695 type

* remove some not needed block till done

* cleanup august tests

* switch to freezegun

* snapshots for dev reg

* SOURCE_USER nit

* snapshots

* pytest.raises

* not loaded check
pull/124874/head
J. Nick Koston 2024-08-29 07:32:13 -10:00 committed by GitHub
parent 149aebb0bc
commit a04970bd54
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
19 changed files with 312 additions and 422 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
homeassistant/components/august/__init__.py
View File

@ -24,7 +24,7 @@ from .util import async_create_august_clientsession
type AugustConfigEntry = ConfigEntry[AugustData]
async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
async def async_setup_entry(hass: HomeAssistant, entry: AugustConfigEntry) -> bool:
"""Set up August from a config entry."""
session = async_create_august_clientsession(hass)
august_gateway = AugustGateway(Path(hass.config.config_dir), session)

11
homeassistant/components/august/binary_sensor.py
View File

@ -109,12 +109,11 @@ async def async_setup_entry(
for description in SENSOR_TYPES_DOORBELL
)
for doorbell in data.doorbells:
entities.extend(
AugustDoorbellBinarySensor(data, doorbell, description)
for description in SENSOR_TYPES_DOORBELL + SENSOR_TYPES_VIDEO_DOORBELL
)
entities.extend(
AugustDoorbellBinarySensor(data, doorbell, description)
for description in SENSOR_TYPES_DOORBELL + SENSOR_TYPES_VIDEO_DOORBELL
for doorbell in data.doorbells
)
async_add_entities(entities)

4
homeassistant/components/august/button.py
View File

@ -5,7 +5,7 @@ from homeassistant.core import HomeAssistant, callback
from homeassistant.helpers.entity_platform import AddEntitiesCallback
from . import AugustConfigEntry
from .entity import AugustEntityMixin
from .entity import AugustEntity
async def async_setup_entry(
@ -18,7 +18,7 @@ async def async_setup_entry(
async_add_entities(AugustWakeLockButton(data, lock, "wake") for lock in data.locks)
class AugustWakeLockButton(AugustEntityMixin, ButtonEntity):
class AugustWakeLockButton(AugustEntity, ButtonEntity):
"""Representation of an August lock wake button."""
_attr_translation_key = "wake"

4
homeassistant/components/august/camera.py
View File

@ -16,7 +16,7 @@ from homeassistant.helpers.entity_platform import AddEntitiesCallback
from . import AugustConfigEntry, AugustData
from .const import DEFAULT_NAME, DEFAULT_TIMEOUT
from .entity import AugustEntityMixin
from .entity import AugustEntity
_LOGGER = logging.getLogger(__name__)
@ -38,7 +38,7 @@ async def async_setup_entry(
)
class AugustCamera(AugustEntityMixin, Camera):
class AugustCamera(AugustEntity, Camera):
"""An implementation of an August security camera."""
_attr_translation_key = "camera"

4
homeassistant/components/august/entity.py
View File

@ -20,7 +20,7 @@ from .const import MANUFACTURER
DEVICE_TYPES = ["keypad", "lock", "camera", "doorbell", "door", "bell"]
class AugustEntityMixin(Entity):
class AugustEntity(Entity):
"""Base implementation for August device."""
_attr_should_poll = False
@ -87,7 +87,7 @@ class AugustEntityMixin(Entity):
self._update_from_data()
class AugustDescriptionEntity(AugustEntityMixin):
class AugustDescriptionEntity(AugustEntity):
"""An August entity with a description."""
def __init__(

28
homeassistant/components/august/event.py
View File

@ -63,22 +63,17 @@ async def async_setup_entry(
) -> None:
"""Set up the august event platform."""
data = config_entry.runtime_data
entities: list[AugustEventEntity] = []
for lock in data.locks:
detail = data.get_device_detail(lock.device_id)
if detail.doorbell:
entities.extend(
AugustEventEntity(data, lock, description)
for description in TYPES_DOORBELL
)
for doorbell in data.doorbells:
entities.extend(
AugustEventEntity(data, doorbell, description)
for description in TYPES_DOORBELL + TYPES_VIDEO_DOORBELL
)
entities: list[AugustEventEntity] = [
AugustEventEntity(data, lock, description)
for description in TYPES_DOORBELL
for lock in data.locks
if (detail := data.get_device_detail(lock.device_id)) and detail.doorbell
]
entities.extend(
AugustEventEntity(data, doorbell, description)
for description in TYPES_DOORBELL + TYPES_VIDEO_DOORBELL
for doorbell in data.doorbells
)
async_add_entities(entities)
@ -86,7 +81,6 @@ class AugustEventEntity(AugustDescriptionEntity, EventEntity):
"""An august event entity."""
entity_description: AugustEventEntityDescription
_attr_has_entity_name = True
_last_activity: Activity | None = None
@callback

4
homeassistant/components/august/lock.py
View File

@ -19,7 +19,7 @@ from homeassistant.helpers.restore_state import RestoreEntity
import homeassistant.util.dt as dt_util
from . import AugustConfigEntry, AugustData
from .entity import AugustEntityMixin
from .entity import AugustEntity
_LOGGER = logging.getLogger(__name__)
@ -36,7 +36,7 @@ async def async_setup_entry(
async_add_entities(AugustLock(data, lock) for lock in data.locks)
class AugustLock(AugustEntityMixin, RestoreEntity, LockEntity):
class AugustLock(AugustEntity, RestoreEntity, LockEntity):
"""Representation of an August lock."""
_attr_name = None

21
homeassistant/components/august/sensor.py
View File

@ -4,7 +4,7 @@ from __future__ import annotations
from collections.abc import Callable
from dataclasses import dataclass
from typing import Any, Generic, TypeVar, cast
from typing import Any, cast
from yalexs.activity import ActivityType, LockOperationActivity
from yalexs.doorbell import Doorbell
@ -42,7 +42,7 @@ from .const import (
OPERATION_METHOD_REMOTE,
OPERATION_METHOD_TAG,
)
from .entity import AugustDescriptionEntity, AugustEntityMixin
from .entity import AugustDescriptionEntity, AugustEntity
def _retrieve_device_battery_state(detail: LockDetail) -> int:
@ -55,14 +55,13 @@ def _retrieve_linked_keypad_battery_state(detail: KeypadDetail) -> int | None:
return detail.battery_percentage
_T = TypeVar("_T", LockDetail, KeypadDetail)
@dataclass(frozen=True, kw_only=True)
class AugustSensorEntityDescription(SensorEntityDescription, Generic[_T]):
class AugustSensorEntityDescription[T: LockDetail | KeypadDetail](
SensorEntityDescription
):
"""Mixin for required keys."""
value_fn: Callable[[_T], int | None]
value_fn: Callable[[T], int | None]
SENSOR_TYPE_DEVICE_BATTERY = AugustSensorEntityDescription[LockDetail](
@ -114,7 +113,7 @@ async def async_setup_entry(
async_add_entities(entities)
class AugustOperatorSensor(AugustEntityMixin, RestoreSensor):
class AugustOperatorSensor(AugustEntity, RestoreSensor):
"""Representation of an August lock operation sensor."""
_attr_translation_key = "operator"
@ -198,10 +197,12 @@ class AugustOperatorSensor(AugustEntityMixin, RestoreSensor):
self._operated_autorelock = last_attrs[ATTR_OPERATION_AUTORELOCK]
class AugustBatterySensor(AugustDescriptionEntity, SensorEntity, Generic[_T]):
class AugustBatterySensor[T: LockDetail | KeypadDetail](
AugustDescriptionEntity, SensorEntity
):
"""Representation of an August sensor."""
entity_description: AugustSensorEntityDescription[_T]
entity_description: AugustSensorEntityDescription[T]
_attr_device_class = SensorDeviceClass.BATTERY
_attr_native_unit_of_measurement = PERCENTAGE

7
homeassistant/components/august/util.py
View File

@ -63,16 +63,11 @@ def _activity_time_based(latest: Activity) -> Activity | None:
"""Get the latest state of the sensor."""
start = latest.activity_start_time
end = latest.activity_end_time + TIME_TO_DECLARE_DETECTION
if start <= _native_datetime() <= end:
if start <= datetime.now() <= end:
return latest
return None
def _native_datetime() -> datetime:
"""Return time in the format august uses without timezone."""
return datetime.now()
def retrieve_online_state(
data: AugustData, detail: DoorbellDetail | LockDetail
) -> bool:

33
tests/components/august/snapshots/test_binary_sensor.ambr Normal file
View File

@ -0,0 +1,33 @@
# serializer version: 1
# name: test_doorbell_device_registry
DeviceRegistryEntrySnapshot({
'area_id': 'tmt100_name',
'config_entries': <ANY>,
'configuration_url': 'https://account.august.com',
'connections': set({
}),
'disabled_by': None,
'entry_type': None,
'hw_version': None,
'id': <ANY>,
'identifiers': set({
tuple(
'august',
'tmt100',
),
}),
'is_new': False,
'labels': set({
}),
'manufacturer': 'August Home Inc.',
'model': 'hydra1',
'model_id': None,
'name': 'tmt100 Name',
'name_by_user': None,
'primary_config_entry': <ANY>,
'serial_number': None,
'suggested_area': 'tmt100 Name',
'sw_version': '3.1.0-HYDRC75+201909251139',
'via_device_id': None,
})
# ---

37
tests/components/august/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.august.com',
'connections': set({
tuple(
'bluetooth',
'12:22',
),
}),
'disabled_by': None,
'entry_type': None,
'hw_version': None,
'id': <ANY>,
'identifiers': set({
tuple(
'august',
'online_with_doorsense',
),
}),
'is_new': False,
'labels': set({
}),
'manufacturer': 'August 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,
})
# ---

239
tests/components/august/test_binary_sensor.py
View File

@ -1,8 +1,10 @@
"""The binary_sensor tests for the august platform."""
import datetime
from unittest.mock import Mock, patch
from unittest.mock import Mock
from freezegun.api import FrozenDateTimeFactory
from syrupy import SnapshotAssertion
from yalexs.pubnub_async import AugustPubNub
from homeassistant.components.lock import DOMAIN as LOCK_DOMAIN
@ -36,28 +38,20 @@ async def test_doorsense(hass: HomeAssistant) -> None:
hass, "get_lock.online_with_doorsense.json"
)
await _create_august_with_devices(hass, [lock_one])
states = hass.states
binary_sensor_online_with_doorsense_name = hass.states.get(
"binary_sensor.online_with_doorsense_name_door"
)
assert binary_sensor_online_with_doorsense_name.state == STATE_ON
assert states.get("binary_sensor.online_with_doorsense_name_door").state == STATE_ON
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()
binary_sensor_online_with_doorsense_name = hass.states.get(
"binary_sensor.online_with_doorsense_name_door"
)
assert binary_sensor_online_with_doorsense_name.state == STATE_ON
assert states.get("binary_sensor.online_with_doorsense_name_door").state == STATE_ON
await hass.services.async_call(LOCK_DOMAIN, SERVICE_LOCK, data, blocking=True)
await hass.async_block_till_done()
binary_sensor_online_with_doorsense_name = hass.states.get(
"binary_sensor.online_with_doorsense_name_door"
assert (
states.get("binary_sensor.online_with_doorsense_name_door").state == STATE_OFF
)
assert binary_sensor_online_with_doorsense_name.state == STATE_OFF
async def test_lock_bridge_offline(hass: HomeAssistant) -> None:
@ -69,113 +63,82 @@ async def test_lock_bridge_offline(hass: HomeAssistant) -> None:
hass, "get_activity.bridge_offline.json"
)
await _create_august_with_devices(hass, [lock_one], activities=activities)
binary_sensor_online_with_doorsense_name = hass.states.get(
"binary_sensor.online_with_doorsense_name_door"
states = hass.states
assert (
states.get("binary_sensor.online_with_doorsense_name_door").state
== STATE_UNAVAILABLE
)
assert binary_sensor_online_with_doorsense_name.state == STATE_UNAVAILABLE
async def test_create_doorbell(hass: HomeAssistant) -> None:
"""Test creation of a doorbell."""
doorbell_one = await _mock_doorbell_from_fixture(hass, "get_doorbell.json")
await _create_august_with_devices(hass, [doorbell_one])
states = hass.states
binary_sensor_k98gidt45gul_name_motion = hass.states.get(
"binary_sensor.k98gidt45gul_name_motion"
assert states.get("binary_sensor.k98gidt45gul_name_motion").state == STATE_OFF
assert (
states.get("binary_sensor.k98gidt45gul_name_image_capture").state == STATE_OFF
)
assert binary_sensor_k98gidt45gul_name_motion.state == STATE_OFF
binary_sensor_k98gidt45gul_name_image_capture = hass.states.get(
"binary_sensor.k98gidt45gul_name_image_capture"
assert states.get("binary_sensor.k98gidt45gul_name_connectivity").state == STATE_ON
assert (
states.get("binary_sensor.k98gidt45gul_name_doorbell_ding").state == STATE_OFF
)
assert binary_sensor_k98gidt45gul_name_image_capture.state == STATE_OFF
binary_sensor_k98gidt45gul_name_online = hass.states.get(
"binary_sensor.k98gidt45gul_name_connectivity"
assert states.get("binary_sensor.k98gidt45gul_name_motion").state == STATE_OFF
assert (
states.get("binary_sensor.k98gidt45gul_name_image_capture").state == STATE_OFF
)
assert binary_sensor_k98gidt45gul_name_online.state == STATE_ON
binary_sensor_k98gidt45gul_name_ding = hass.states.get(
"binary_sensor.k98gidt45gul_name_doorbell_ding"
)
assert binary_sensor_k98gidt45gul_name_ding.state == STATE_OFF
binary_sensor_k98gidt45gul_name_motion = hass.states.get(
"binary_sensor.k98gidt45gul_name_motion"
)
assert binary_sensor_k98gidt45gul_name_motion.state == STATE_OFF
binary_sensor_k98gidt45gul_name_image_capture = hass.states.get(
"binary_sensor.k98gidt45gul_name_image_capture"
)
assert binary_sensor_k98gidt45gul_name_image_capture.state == STATE_OFF
async def test_create_doorbell_offline(hass: HomeAssistant) -> None:
"""Test creation of a doorbell that is offline."""
doorbell_one = await _mock_doorbell_from_fixture(hass, "get_doorbell.offline.json")
await _create_august_with_devices(hass, [doorbell_one])
states = hass.states
binary_sensor_tmt100_name_motion = hass.states.get(
"binary_sensor.tmt100_name_motion"
assert states.get("binary_sensor.tmt100_name_motion").state == STATE_UNAVAILABLE
assert states.get("binary_sensor.tmt100_name_connectivity").state == STATE_OFF
assert (
states.get("binary_sensor.tmt100_name_doorbell_ding").state == STATE_UNAVAILABLE
)
assert binary_sensor_tmt100_name_motion.state == STATE_UNAVAILABLE
binary_sensor_tmt100_name_online = hass.states.get(
"binary_sensor.tmt100_name_connectivity"
)
assert binary_sensor_tmt100_name_online.state == STATE_OFF
binary_sensor_tmt100_name_ding = hass.states.get(
"binary_sensor.tmt100_name_doorbell_ding"
)
assert binary_sensor_tmt100_name_ding.state == STATE_UNAVAILABLE
async def test_create_doorbell_with_motion(hass: HomeAssistant) -> None:
async def test_create_doorbell_with_motion(
hass: HomeAssistant, freezer: FrozenDateTimeFactory
) -> None:
"""Test creation of a doorbell."""
doorbell_one = await _mock_doorbell_from_fixture(hass, "get_doorbell.json")
activities = await _mock_activities_from_fixture(
hass, "get_activity.doorbell_motion.json"
)
await _create_august_with_devices(hass, [doorbell_one], activities=activities)
states = hass.states
binary_sensor_k98gidt45gul_name_motion = hass.states.get(
"binary_sensor.k98gidt45gul_name_motion"
assert states.get("binary_sensor.k98gidt45gul_name_motion").state == STATE_ON
assert states.get("binary_sensor.k98gidt45gul_name_connectivity").state == STATE_ON
assert (
states.get("binary_sensor.k98gidt45gul_name_doorbell_ding").state == STATE_OFF
)
assert binary_sensor_k98gidt45gul_name_motion.state == STATE_ON
binary_sensor_k98gidt45gul_name_online = hass.states.get(
"binary_sensor.k98gidt45gul_name_connectivity"
)
assert binary_sensor_k98gidt45gul_name_online.state == STATE_ON
binary_sensor_k98gidt45gul_name_ding = hass.states.get(
"binary_sensor.k98gidt45gul_name_doorbell_ding"
)
assert binary_sensor_k98gidt45gul_name_ding.state == STATE_OFF
new_time = dt_util.utcnow() + datetime.timedelta(seconds=40)
native_time = datetime.datetime.now() + datetime.timedelta(seconds=40)
with patch(
"homeassistant.components.august.util._native_datetime",
return_value=native_time,
):
async_fire_time_changed(hass, new_time)
await hass.async_block_till_done()
binary_sensor_k98gidt45gul_name_motion = hass.states.get(
"binary_sensor.k98gidt45gul_name_motion"
)
assert binary_sensor_k98gidt45gul_name_motion.state == STATE_OFF
freezer.tick(40)
async_fire_time_changed(hass)
await hass.async_block_till_done()
assert states.get("binary_sensor.k98gidt45gul_name_motion").state == STATE_OFF
async def test_doorbell_update_via_pubnub(hass: HomeAssistant) -> None:
async def test_doorbell_update_via_pubnub(
hass: HomeAssistant, freezer: FrozenDateTimeFactory
) -> None:
"""Test creation of a doorbell that can be updated via pubnub."""
doorbell_one = await _mock_doorbell_from_fixture(hass, "get_doorbell.json")
pubnub = AugustPubNub()
await _create_august_with_devices(hass, [doorbell_one], pubnub=pubnub)
assert doorbell_one.pubsub_channel == "7c7a6672-59c8-3333-ffff-dcd98705cccc"
binary_sensor_k98gidt45gul_name_motion = hass.states.get(
"binary_sensor.k98gidt45gul_name_motion"
states = hass.states
assert states.get("binary_sensor.k98gidt45gul_name_motion").state == STATE_OFF
assert (
states.get("binary_sensor.k98gidt45gul_name_doorbell_ding").state == STATE_OFF
)
assert binary_sensor_k98gidt45gul_name_motion.state == STATE_OFF
binary_sensor_k98gidt45gul_name_ding = hass.states.get(
"binary_sensor.k98gidt45gul_name_doorbell_ding"
)
assert binary_sensor_k98gidt45gul_name_ding.state == STATE_OFF
pubnub.message(
pubnub,
@ -198,10 +161,7 @@ async def test_doorbell_update_via_pubnub(hass: HomeAssistant) -> None:
await hass.async_block_till_done()
binary_sensor_k98gidt45gul_name_image_capture = hass.states.get(
"binary_sensor.k98gidt45gul_name_image_capture"
)
assert binary_sensor_k98gidt45gul_name_image_capture.state == STATE_ON
assert states.get("binary_sensor.k98gidt45gul_name_image_capture").state == STATE_ON
pubnub.message(
pubnub,
@ -235,29 +195,19 @@ async def test_doorbell_update_via_pubnub(hass: HomeAssistant) -> None:
await hass.async_block_till_done()
binary_sensor_k98gidt45gul_name_motion = hass.states.get(
"binary_sensor.k98gidt45gul_name_motion"
)
assert binary_sensor_k98gidt45gul_name_motion.state == STATE_ON
assert states.get("binary_sensor.k98gidt45gul_name_motion").state == STATE_ON
binary_sensor_k98gidt45gul_name_ding = hass.states.get(
"binary_sensor.k98gidt45gul_name_doorbell_ding"
assert (
states.get("binary_sensor.k98gidt45gul_name_doorbell_ding").state == STATE_OFF
)
assert binary_sensor_k98gidt45gul_name_ding.state == STATE_OFF
new_time = dt_util.utcnow() + datetime.timedelta(seconds=40)
native_time = datetime.datetime.now() + datetime.timedelta(seconds=40)
with patch(
"homeassistant.components.august.util._native_datetime",
return_value=native_time,
):
async_fire_time_changed(hass, new_time)
await hass.async_block_till_done()
freezer.tick(40)
async_fire_time_changed(hass)
await hass.async_block_till_done()
binary_sensor_k98gidt45gul_name_image_capture = hass.states.get(
"binary_sensor.k98gidt45gul_name_image_capture"
assert (
states.get("binary_sensor.k98gidt45gul_name_image_capture").state == STATE_OFF
)
assert binary_sensor_k98gidt45gul_name_image_capture.state == STATE_OFF
pubnub.message(
pubnub,
@ -271,37 +221,25 @@ async def test_doorbell_update_via_pubnub(hass: HomeAssistant) -> None:
)
await hass.async_block_till_done()
binary_sensor_k98gidt45gul_name_ding = hass.states.get(
"binary_sensor.k98gidt45gul_name_doorbell_ding"
)
assert binary_sensor_k98gidt45gul_name_ding.state == STATE_ON
new_time = dt_util.utcnow() + datetime.timedelta(seconds=40)
native_time = datetime.datetime.now() + datetime.timedelta(seconds=40)
with patch(
"homeassistant.components.august.util._native_datetime",
return_value=native_time,
):
async_fire_time_changed(hass, new_time)
await hass.async_block_till_done()
assert states.get("binary_sensor.k98gidt45gul_name_doorbell_ding").state == STATE_ON
freezer.tick(40)
async_fire_time_changed(hass)
await hass.async_block_till_done()
binary_sensor_k98gidt45gul_name_ding = hass.states.get(
"binary_sensor.k98gidt45gul_name_doorbell_ding"
assert (
states.get("binary_sensor.k98gidt45gul_name_doorbell_ding").state == STATE_OFF
)
assert binary_sensor_k98gidt45gul_name_ding.state == STATE_OFF
async def test_doorbell_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."""
doorbell_one = await _mock_doorbell_from_fixture(hass, "get_doorbell.offline.json")
await _create_august_with_devices(hass, [doorbell_one])
reg_device = device_registry.async_get_device(identifiers={("august", "tmt100")})
assert reg_device.model == "hydra1"
assert reg_device.name == "tmt100 Name"
assert reg_device.manufacturer == "August Home Inc."
assert reg_device.sw_version == "3.1.0-HYDRC75+201909251139"
assert reg_device == snapshot
async def test_door_sense_update_via_pubnub(hass: HomeAssistant) -> None:
@ -314,11 +252,9 @@ async def test_door_sense_update_via_pubnub(hass: HomeAssistant) -> None:
config_entry = await _create_august_with_devices(
hass, [lock_one], activities=activities, pubnub=pubnub
)
states = hass.states
binary_sensor_online_with_doorsense_name = hass.states.get(
"binary_sensor.online_with_doorsense_name_door"
)
assert binary_sensor_online_with_doorsense_name.state == STATE_ON
assert states.get("binary_sensor.online_with_doorsense_name_door").state == STATE_ON
pubnub.message(
pubnub,
@ -330,10 +266,9 @@ async def test_door_sense_update_via_pubnub(hass: HomeAssistant) -> None:
)
await hass.async_block_till_done()
binary_sensor_online_with_doorsense_name = hass.states.get(
"binary_sensor.online_with_doorsense_name_door"
assert (
states.get("binary_sensor.online_with_doorsense_name_door").state == STATE_OFF
)
assert binary_sensor_online_with_doorsense_name.state == STATE_OFF
pubnub.message(
pubnub,
@ -344,33 +279,22 @@ async def test_door_sense_update_via_pubnub(hass: HomeAssistant) -> None:
),
)
await hass.async_block_till_done()
binary_sensor_online_with_doorsense_name = hass.states.get(
"binary_sensor.online_with_doorsense_name_door"
)
assert binary_sensor_online_with_doorsense_name.state == STATE_ON
assert states.get("binary_sensor.online_with_doorsense_name_door").state == STATE_ON
async_fire_time_changed(hass, dt_util.utcnow() + datetime.timedelta(seconds=30))
await hass.async_block_till_done()
binary_sensor_online_with_doorsense_name = hass.states.get(
"binary_sensor.online_with_doorsense_name_door"
)
assert binary_sensor_online_with_doorsense_name.state == STATE_ON
assert states.get("binary_sensor.online_with_doorsense_name_door").state == STATE_ON
pubnub.connected = True
async_fire_time_changed(hass, dt_util.utcnow() + datetime.timedelta(seconds=30))
await hass.async_block_till_done()
binary_sensor_online_with_doorsense_name = hass.states.get(
"binary_sensor.online_with_doorsense_name_door"
)
assert binary_sensor_online_with_doorsense_name.state == STATE_ON
assert states.get("binary_sensor.online_with_doorsense_name_door").state == STATE_ON
# Ensure pubnub status is always preserved
async_fire_time_changed(hass, dt_util.utcnow() + datetime.timedelta(hours=2))
await hass.async_block_till_done()
binary_sensor_online_with_doorsense_name = hass.states.get(
"binary_sensor.online_with_doorsense_name_door"
)
assert binary_sensor_online_with_doorsense_name.state == STATE_ON
assert states.get("binary_sensor.online_with_doorsense_name_door").state == STATE_ON
pubnub.message(
pubnub,
@ -381,17 +305,11 @@ async def test_door_sense_update_via_pubnub(hass: HomeAssistant) -> None:
),
)
await hass.async_block_till_done()
binary_sensor_online_with_doorsense_name = hass.states.get(
"binary_sensor.online_with_doorsense_name_door"
)
assert binary_sensor_online_with_doorsense_name.state == STATE_ON
assert states.get("binary_sensor.online_with_doorsense_name_door").state == STATE_ON
async_fire_time_changed(hass, dt_util.utcnow() + datetime.timedelta(hours=4))
await hass.async_block_till_done()
binary_sensor_online_with_doorsense_name = hass.states.get(
"binary_sensor.online_with_doorsense_name_door"
)
assert binary_sensor_online_with_doorsense_name.state == STATE_ON
assert states.get("binary_sensor.online_with_doorsense_name_door").state == STATE_ON
await hass.config_entries.async_unload(config_entry.entry_id)
await hass.async_block_till_done()
@ -402,7 +320,10 @@ async def test_create_lock_with_doorbell(hass: HomeAssistant) -> None:
lock_one = await _mock_lock_from_fixture(hass, "lock_with_doorbell.online.json")
await _create_august_with_devices(hass, [lock_one])
ding_sensor = hass.states.get(
"binary_sensor.a6697750d607098bae8d6baa11ef8063_name_doorbell_ding"
states = hass.states
assert (
states.get(
"binary_sensor.a6697750d607098bae8d6baa11ef8063_name_doorbell_ding"
).state
== STATE_OFF
)
assert ding_sensor.state == STATE_OFF

1
tests/components/august/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()

10
tests/components/august/test_camera.py
View File

@ -25,14 +25,10 @@ async def test_create_doorbell(
):
await _create_august_with_devices(hass, [doorbell_one], brand=Brand.AUGUST)
camera_k98gidt45gul_name_camera = hass.states.get(
"camera.k98gidt45gul_name_camera"
)
assert camera_k98gidt45gul_name_camera.state == STATE_IDLE
camera_state = hass.states.get("camera.k98gidt45gul_name_camera")
assert camera_state.state == STATE_IDLE
url = hass.states.get("camera.k98gidt45gul_name_camera").attributes[
"entity_picture"
]
url = camera_state.attributes["entity_picture"]
client = await hass_client_no_auth()
resp = await client.get(url)

14
tests/components/august/test_config_flow.py
View File

@ -5,7 +5,6 @@ from unittest.mock import patch
from yalexs.authenticator_common import ValidationResult
from yalexs.manager.exceptions import CannotConnect, InvalidAuth, RequireValidation
from homeassistant import config_entries
from homeassistant.components.august.const import (
CONF_ACCESS_TOKEN_CACHE_FILE,
CONF_BRAND,
@ -14,6 +13,7 @@ from homeassistant.components.august.const import (
DOMAIN,
VERIFICATION_CODE_KEY,
)
from homeassistant.config_entries import SOURCE_USER
from homeassistant.const import CONF_PASSWORD, CONF_TIMEOUT, CONF_USERNAME
from homeassistant.core import HomeAssistant
from homeassistant.data_entry_flow import FlowResultType
@ -25,7 +25,7 @@ async def test_form(hass: HomeAssistant) -> None:
"""Test we get the form."""
result = await hass.config_entries.flow.async_init(
DOMAIN, context={"source": config_entries.SOURCE_USER}
DOMAIN, context={"source": SOURCE_USER}
)
assert result["type"] is FlowResultType.FORM
assert result["errors"] == {}
@ -66,7 +66,7 @@ async def test_form(hass: HomeAssistant) -> None:
async def test_form_invalid_auth(hass: HomeAssistant) -> None:
"""Test we handle invalid auth."""
result = await hass.config_entries.flow.async_init(
DOMAIN, context={"source": config_entries.SOURCE_USER}
DOMAIN, context={"source": SOURCE_USER}
)
with patch(
@ -90,7 +90,7 @@ async def test_form_invalid_auth(hass: HomeAssistant) -> None:
async def test_user_unexpected_exception(hass: HomeAssistant) -> None:
"""Test we handle an unexpected exception."""
result = await hass.config_entries.flow.async_init(
DOMAIN, context={"source": config_entries.SOURCE_USER}
DOMAIN, context={"source": SOURCE_USER}
)
with patch(
@ -115,7 +115,7 @@ async def test_user_unexpected_exception(hass: HomeAssistant) -> None:
async def test_form_cannot_connect(hass: HomeAssistant) -> None:
"""Test we handle cannot connect error."""
result = await hass.config_entries.flow.async_init(
DOMAIN, context={"source": config_entries.SOURCE_USER}
DOMAIN, context={"source": SOURCE_USER}
)
with patch(
@ -138,7 +138,7 @@ async def test_form_cannot_connect(hass: HomeAssistant) -> None:
async def test_form_needs_validate(hass: HomeAssistant) -> None:
"""Test we present validation when we need to validate."""
result = await hass.config_entries.flow.async_init(
DOMAIN, context={"source": config_entries.SOURCE_USER}
DOMAIN, context={"source": SOURCE_USER}
)
with (
@ -367,7 +367,7 @@ async def test_switching_brands(hass: HomeAssistant) -> None:
)
entry.add_to_hass(hass)
result = await hass.config_entries.flow.async_init(
DOMAIN, context={"source": config_entries.SOURCE_USER}
DOMAIN, context={"source": SOURCE_USER}
)
assert result["type"] is FlowResultType.FORM
assert result["errors"] == {}

46
tests/components/august/test_event.py
View File

@ -1,13 +1,12 @@
"""The event tests for the august."""
import datetime
from unittest.mock import Mock, patch
from unittest.mock import Mock
from freezegun.api import FrozenDateTimeFactory
from yalexs.pubnub_async import AugustPubNub
from homeassistant.const import STATE_UNAVAILABLE, STATE_UNKNOWN
from homeassistant.core import HomeAssistant
import homeassistant.util.dt as dt_util
from .mocks import (
_create_august_with_devices,
@ -45,7 +44,9 @@ async def test_create_doorbell_offline(hass: HomeAssistant) -> None:
assert doorbell_state.state == STATE_UNAVAILABLE
async def test_create_doorbell_with_motion(hass: HomeAssistant) -> None:
async def test_create_doorbell_with_motion(
hass: HomeAssistant, freezer: FrozenDateTimeFactory
) -> None:
"""Test creation of a doorbell."""
doorbell_one = await _mock_doorbell_from_fixture(hass, "get_doorbell.json")
activities = await _mock_activities_from_fixture(
@ -61,19 +62,16 @@ async def test_create_doorbell_with_motion(hass: HomeAssistant) -> None:
assert doorbell_state is not None
assert doorbell_state.state == STATE_UNKNOWN
new_time = dt_util.utcnow() + datetime.timedelta(seconds=40)
native_time = datetime.datetime.now() + datetime.timedelta(seconds=40)
with patch(
"homeassistant.components.august.util._native_datetime",
return_value=native_time,
):
async_fire_time_changed(hass, new_time)
await hass.async_block_till_done()
freezer.tick(40)
async_fire_time_changed(hass)
await hass.async_block_till_done()
motion_state = hass.states.get("event.k98gidt45gul_name_motion")
assert motion_state.state == isotime
async def test_doorbell_update_via_pubnub(hass: HomeAssistant) -> None:
async def test_doorbell_update_via_pubnub(
hass: HomeAssistant, freezer: FrozenDateTimeFactory
) -> None:
"""Test creation of a doorbell that can be updated via pubnub."""
doorbell_one = await _mock_doorbell_from_fixture(hass, "get_doorbell.json")
pubnub = AugustPubNub()
@ -125,14 +123,9 @@ async def test_doorbell_update_via_pubnub(hass: HomeAssistant) -> None:
assert motion_state.state != STATE_UNKNOWN
isotime = motion_state.state
new_time = dt_util.utcnow() + datetime.timedelta(seconds=40)
native_time = datetime.datetime.now() + datetime.timedelta(seconds=40)
with patch(
"homeassistant.components.august.util._native_datetime",
return_value=native_time,
):
async_fire_time_changed(hass, new_time)
await hass.async_block_till_done()
freezer.tick(40)
async_fire_time_changed(hass)
await hass.async_block_till_done()
motion_state = hass.states.get("event.k98gidt45gul_name_motion")
assert motion_state is not None
@ -155,14 +148,9 @@ async def test_doorbell_update_via_pubnub(hass: HomeAssistant) -> None:
assert doorbell_state.state != STATE_UNKNOWN
isotime = motion_state.state
new_time = dt_util.utcnow() + datetime.timedelta(seconds=40)
native_time = datetime.datetime.now() + datetime.timedelta(seconds=40)
with patch(
"homeassistant.components.august.util._native_datetime",
return_value=native_time,
):
async_fire_time_changed(hass, new_time)
await hass.async_block_till_done()
freezer.tick(40)
async_fire_time_changed(hass)
await hass.async_block_till_done()
doorbell_state = hass.states.get("event.k98gidt45gul_name_doorbell")
assert doorbell_state is not None

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

@ -122,16 +122,16 @@ async def test_unlock_throws_august_api_http_error(hass: HomeAssistant) -> None:
"unlock_return_activities": _unlock_return_activities_side_effect
},
)
last_err = None
data = {ATTR_ENTITY_ID: "lock.a6697750d607098bae8d6baa11ef8063_name"}
try:
with pytest.raises(
HomeAssistantError,
match=(
"A6697750D607098BAE8D6BAA11EF8063 Name: This should bubble up as its user"
" consumable"
),
):
await hass.services.async_call(LOCK_DOMAIN, SERVICE_UNLOCK, data, blocking=True)
except HomeAssistantError as err:
last_err = err
assert str(last_err) == (
"A6697750D607098BAE8D6BAA11EF8063 Name: This should bubble up as its user"
" consumable"
)
async def test_lock_throws_august_api_http_error(hass: HomeAssistant) -> None:
@ -152,16 +152,15 @@ async def test_lock_throws_august_api_http_error(hass: HomeAssistant) -> None:
"lock_return_activities": _lock_return_activities_side_effect
},
)
last_err = None
data = {ATTR_ENTITY_ID: "lock.a6697750d607098bae8d6baa11ef8063_name"}
try:
with pytest.raises(
HomeAssistantError,
match=(
"A6697750D607098BAE8D6BAA11EF8063 Name: This should bubble up as its user"
" consumable"
),
):
await hass.services.async_call(LOCK_DOMAIN, SERVICE_LOCK, data, blocking=True)
except HomeAssistantError as err:
last_err = err
assert str(last_err) == (
"A6697750D607098BAE8D6BAA11EF8063 Name: This should bubble up as its user"
" consumable"
)
async def test_open_throws_hass_service_not_supported_error(
@ -371,6 +370,7 @@ async def test_load_unload(hass: HomeAssistant) -> None:
await hass.config_entries.async_unload(config_entry.entry_id)
await hass.async_block_till_done()
assert config_entry.state is ConfigEntryState.NOT_LOADED
async def test_load_triggers_ble_discovery(

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

@ -6,6 +6,7 @@ from unittest.mock import Mock
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 yalexs.pubnub_async import AugustPubNub
@ -43,7 +44,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_august_lock_detail(hass)
@ -52,10 +53,7 @@ async def test_lock_device_registry(
reg_device = device_registry.async_get_device(
identifiers={("august", "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 == "August Home Inc."
assert reg_device == snapshot
async def test_lock_changed_by(hass: HomeAssistant) -> None:
@ -65,14 +63,10 @@ async def test_lock_changed_by(hass: HomeAssistant) -> None:
activities = await _mock_activities_from_fixture(hass, "get_activity.lock.json")
await _create_august_with_devices(hass, [lock_one], activities=activities)
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_online_with_doorsense_name.attributes.get("changed_by")
== "Your favorite elven princess"
)
assert lock_state.state == STATE_LOCKED
assert lock_state.attributes["changed_by"] == "Your favorite elven princess"
async def test_state_locking(hass: HomeAssistant) -> None:
@ -82,9 +76,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)
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:
@ -96,9 +88,7 @@ async def test_state_unlocking(hass: HomeAssistant) -> None:
)
await _create_august_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_UNLOCKING
assert hass.states.get("lock.online_with_doorsense_name").state == STATE_UNLOCKING
async def test_state_jammed(hass: HomeAssistant) -> None:
@ -108,9 +98,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)
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(
@ -119,35 +107,27 @@ async def test_one_lock_operation(
"""Test creation of a lock with doorsense and bridge."""
lock_one = await _mock_doorsense_enabled_august_lock_detail(hass)
await _create_august_with_devices(hass, [lock_one])
states = hass.states
lock_online_with_doorsense_name = hass.states.get("lock.online_with_doorsense_name")
lock_state = 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 = 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
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(
@ -155,8 +135,7 @@ async def test_one_lock_operation(
)
assert lock_operator_sensor
assert (
hass.states.get("sensor.online_with_doorsense_name_operator").state
== STATE_UNKNOWN
states.get("sensor.online_with_doorsense_name_operator").state == STATE_UNKNOWN
)
@ -170,7 +149,6 @@ async def test_open_lock_operation(hass: HomeAssistant) -> None:
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
@ -189,12 +167,10 @@ async def test_open_lock_operation_pubnub_connected(
await _create_august_with_devices(hass, [lock_with_unlatch], pubnub=pubnub)
pubnub.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()
pubnub.message(
pubnub,
@ -209,8 +185,7 @@ async def test_open_lock_operation_pubnub_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()
@ -227,19 +202,15 @@ async def test_one_lock_operation_pubnub_connected(
await _create_august_with_devices(hass, [lock_one], pubnub=pubnub)
pubnub.connected = True
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()
pubnub.message(
pubnub,
@ -254,17 +225,13 @@ async def test_one_lock_operation_pubnub_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
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()
pubnub.message(
pubnub,
@ -279,8 +246,8 @@ async def test_one_lock_operation_pubnub_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
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(
@ -306,8 +273,8 @@ async def test_one_lock_operation_pubnub_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
lock_state = hass.states.get("lock.online_with_doorsense_name")
assert lock_state.state == STATE_UNLOCKED
async def test_lock_jammed(hass: HomeAssistant) -> None:
@ -325,22 +292,18 @@ async def test_lock_jammed(hass: HomeAssistant) -> None:
},
)
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_JAMMED
lock_state = hass.states.get("lock.online_with_doorsense_name")
assert lock_state.state == STATE_JAMMED
async def test_lock_throws_exception_on_unknown_status_code(
@ -360,15 +323,12 @@ async def test_lock_throws_exception_on_unknown_status_code(
},
)
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"}
with pytest.raises(ClientResponseError):
@ -383,9 +343,7 @@ async def test_one_lock_unknown_state(hass: HomeAssistant) -> None:
)
await _create_august_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:
@ -397,9 +355,7 @@ async def test_lock_bridge_offline(hass: HomeAssistant) -> None:
)
await _create_august_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
assert hass.states.get("lock.online_with_doorsense_name").state == STATE_UNAVAILABLE
async def test_lock_bridge_online(hass: HomeAssistant) -> None:
@ -411,14 +367,13 @@ async def test_lock_bridge_online(hass: HomeAssistant) -> None:
)
await _create_august_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 hass.states.get("lock.online_with_doorsense_name").state == STATE_LOCKED
async def test_lock_update_via_pubnub(hass: HomeAssistant) -> None:
"""Test creation of a lock with doorsense and bridge."""
lock_one = await _mock_doorsense_enabled_august_lock_detail(hass)
states = hass.states
assert lock_one.pubsub_channel == "pubsub"
pubnub = AugustPubNub()
@ -428,9 +383,7 @@ async def test_lock_update_via_pubnub(hass: HomeAssistant) -> None:
)
pubnub.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 states.get("lock.online_with_doorsense_name").state == STATE_LOCKED
pubnub.message(
pubnub,
@ -446,8 +399,7 @@ async def test_lock_update_via_pubnub(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
pubnub.message(
pubnub,
@ -463,25 +415,21 @@ async def test_lock_update_via_pubnub(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 hass.states.get("lock.online_with_doorsense_name").state == STATE_LOCKING
pubnub.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 pubnub 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
pubnub.message(
pubnub,
@ -496,13 +444,11 @@ async def test_lock_update_via_pubnub(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()

71
tests/components/august/test_sensor.py
View File

@ -28,13 +28,9 @@ async def test_create_doorbell(hass: HomeAssistant) -> None:
doorbell_one = await _mock_doorbell_from_fixture(hass, "get_doorbell.json")
await _create_august_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 +40,9 @@ async def test_create_doorbell_offline(
doorbell_one = await _mock_doorbell_from_fixture(hass, "get_doorbell.offline.json")
await _create_august_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
@ -60,8 +56,7 @@ async def test_create_doorbell_hardwired(hass: HomeAssistant) -> None:
)
await _create_august_with_devices(hass, [doorbell_one])
sensor_tmt100_name_battery = hass.states.get("sensor.tmt100_name_battery")
assert sensor_tmt100_name_battery is None
assert hass.states.get("sensor.tmt100_name_battery") is None
async def test_create_lock_with_linked_keypad(
@ -71,25 +66,21 @@ async def test_create_lock_with_linked_keypad(
lock_one = await _mock_lock_from_fixture(hass, "get_lock.doorsense_init.json")
await _create_august_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"
@ -101,42 +92,32 @@ async def test_create_lock_with_low_battery_linked_keypad(
"""Test creation of a lock with a linked keypad that both have a battery."""
lock_one = await _mock_lock_from_fixture(hass, "get_lock.low_keypad_battery.json")
await _create_august_with_devices(hass, [lock_one])
states = hass.states
sensor_a6697750d607098bae8d6baa11ef8063_name_battery = hass.states.get(
"sensor.a6697750d607098bae8d6baa11ef8063_name_battery"
)
assert sensor_a6697750d607098bae8d6baa11ef8063_name_battery.state == "88"
assert (
sensor_a6697750d607098bae8d6baa11ef8063_name_battery.attributes[
"unit_of_measurement"
]
== PERCENTAGE
)
battery_state = states.get("sensor.a6697750d607098bae8d6baa11ef8063_name_battery")
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 == "10"
assert state.attributes[ATTR_UNIT_OF_MEASUREMENT] == PERCENTAGE
keypad_battery_state = states.get("sensor.front_door_lock_keypad_battery")
assert keypad_battery_state.state == "10"
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"
# No activity means it will be unavailable until someone unlocks/locks it
lock_operator_sensor = entity_registry.async_get(
operator_entry = entity_registry.async_get(
"sensor.a6697750d607098bae8d6baa11ef8063_name_operator"
)
assert (
lock_operator_sensor.unique_id
== "A6697750D607098BAE8D6BAA11EF8063_lock_operator"
)
assert (
hass.states.get("sensor.a6697750d607098bae8d6baa11ef8063_name_operator").state
== STATE_UNKNOWN
)
assert operator_entry.unique_id == "A6697750D607098BAE8D6BAA11EF8063_lock_operator"
operator_state = states.get("sensor.a6697750d607098bae8d6baa11ef8063_name_operator")
assert operator_state.state == STATE_UNKNOWN
async def test_lock_operator_bluetooth(