Significantly reduce code in august integration (#32030)

* Significantly reduce code in august integration

* Activity updates can now be processed by py-august
  this allows us to eliminate the activity sync
  code for the door sensors and locks

* Lock and door state can now be consumed from
  the lock detail api which allows us to
  remove the status call apis and reduce
  the number of API calls to august

* Refactor the testing method for locks (part #1)

* Update homeassistant/components/august/binary_sensor.py

Co-Authored-By: Paulus Schoutsen <paulus@home-assistant.io>

* Switch to asynctest instead of unittest for mock.patch

Co-authored-by: Paulus Schoutsen <paulus@home-assistant.io>
This commit is contained in:
J. Nick KostonandPaulus Schoutsen authored and GitHub committed 2020-02-20 21:06:24 -08:00
1 parent a12c4da0ca
commit d4075fb262
17 files changed
+579 -429

No files matched your search

+109 -18
View File
@@ -1,17 +1,83 @@
"""Mocks for the august component."""
import datetime
import json
import os
from unittest.mock import MagicMock, PropertyMock
from asynctest import mock
from august.activity import Activity
from august.api import Api
from august.authenticator import AuthenticationState
from august.doorbell import Doorbell, DoorbellDetail
from august.exceptions import AugustApiHTTPError
from august.lock import Lock, LockDetail
from august.lock import Lock, LockDetail, LockStatus
from homeassistant.components.august import AugustData
from homeassistant.components.august import (
CONF_LOGIN_METHOD,
CONF_PASSWORD,
CONF_USERNAME,
DOMAIN,
AugustData,
)
from homeassistant.components.august.binary_sensor import AugustDoorBinarySensor
from homeassistant.components.august.lock import AugustLock
from homeassistant.setup import async_setup_component
from homeassistant.util import dt
from tests.common import load_fixture
def _mock_get_config():
"""Return a default august config."""
return {
DOMAIN: {
CONF_LOGIN_METHOD: "email",
CONF_USERNAME: "mocked_username",
CONF_PASSWORD: "mocked_password",
}
}
@mock.patch("homeassistant.components.august.Api")
@mock.patch("homeassistant.components.august.Authenticator.authenticate")
async def _mock_setup_august(hass, api_mocks_callback, authenticate_mock, api_mock):
"""Set up august integration."""
authenticate_mock.side_effect = MagicMock(
return_value=_mock_august_authentication("original_token", 1234)
)
api_mocks_callback(api_mock)
assert await async_setup_component(hass, DOMAIN, _mock_get_config())
await hass.async_block_till_done()
return True
async def _create_august_with_devices(hass, lock_details=[], doorbell_details=[]):
locks = []
doorbells = []
for lock in lock_details:
if isinstance(lock, LockDetail):
locks.append(_mock_august_lock(lock.device_id))
for doorbell in doorbell_details:
if isinstance(lock, DoorbellDetail):
doorbells.append(_mock_august_doorbell(doorbell.device_id))
def api_mocks_callback(api):
def get_lock_detail_side_effect(access_token, device_id):
for lock in lock_details:
if isinstance(lock, LockDetail) and lock.device_id == device_id:
return lock
api_instance = MagicMock()
api_instance.get_lock_detail.side_effect = get_lock_detail_side_effect
api_instance.get_operable_locks.return_value = locks
api_instance.get_doorbells.return_value = doorbells
api_instance.lock.return_value = LockStatus.LOCKED
api_instance.unlock.return_value = LockStatus.UNLOCKED
api.return_value = api_instance
await _mock_setup_august(hass, api_mocks_callback)
return True
class MockAugustApiFailing(Api):
"""A mock for py-august Api class that always has an AugustApiHTTPError."""
@@ -61,21 +127,6 @@ class MockAugustComponentDoorBinarySensor(AugustDoorBinarySensor):
self.last_update_door_state["activity_start_time_utc"] = activity_start_time_utc
class MockAugustComponentLock(AugustLock):
"""A mock for august component AugustLock class."""
def _update_lock_status(self, lock_status, activity_start_time_utc):
"""Mock updating the lock status."""
self._data.set_last_lock_status_update_time_utc(
self._lock.device_id, activity_start_time_utc
)
self.last_update_lock_status = {}
self.last_update_lock_status["lock_status"] = lock_status
self.last_update_lock_status[
"activity_start_time_utc"
] = activity_start_time_utc
class MockAugustComponentData(AugustData):
"""A wrapper to mock AugustData."""
@@ -143,6 +194,9 @@ def _mock_august_authenticator():
def _mock_august_authentication(token_text, token_timestamp):
authentication = MagicMock(name="august.authentication")
type(authentication).state = PropertyMock(
return_value=AuthenticationState.AUTHENTICATED
)
type(authentication).access_token = PropertyMock(return_value=token_text)
type(authentication).access_token_expires = PropertyMock(
return_value=token_timestamp
@@ -154,6 +208,31 @@ def _mock_august_lock(lockid="mocklockid1", houseid="mockhouseid1"):
return Lock(lockid, _mock_august_lock_data(lockid=lockid, houseid=houseid))
def _mock_august_doorbell(deviceid="mockdeviceid1", houseid="mockhouseid1"):
return Doorbell(
deviceid, _mock_august_doorbell_data(device=deviceid, houseid=houseid)
)
def _mock_august_doorbell_data(deviceid="mockdeviceid1", houseid="mockhouseid1"):
return {
"_id": deviceid,
"DeviceID": deviceid,
"DeviceName": deviceid + " Name",
"HouseID": houseid,
"UserType": "owner",
"SerialNumber": "mockserial",
"battery": 90,
"currentFirmwareVersion": "mockfirmware",
"Bridge": {
"_id": "bridgeid1",
"firmwareVersion": "mockfirm",
"operative": True,
},
"LockStatus": {"doorState": "open"},
}
def _mock_august_lock_data(lockid="mocklockid1", houseid="mockhouseid1"):
return {
"_id": lockid,
@@ -189,6 +268,18 @@ def _mock_doorsense_enabled_august_lock_detail(lockid):
return LockDetail(doorsense_lock_detail_data)
async def _mock_lock_from_fixture(hass, path):
json_dict = await _load_json_fixture(hass, path)
return LockDetail(json_dict)
async def _load_json_fixture(hass, path):
fixture = await hass.async_add_executor_job(
load_fixture, os.path.join("august", path)
)
return json.loads(fixture)
def _mock_doorsense_missing_august_lock_detail(lockid):
doorsense_lock_detail_data = _mock_august_lock_data(lockid=lockid)
del doorsense_lock_detail_data["LockStatus"]["doorState"]
+1 -89
View File
@@ -1,89 +1 @@
"""The lock tests for the august platform."""
import datetime
from august.activity import ACTION_DOOR_CLOSED, ACTION_DOOR_OPEN
from august.lock import LockDoorStatus
from homeassistant.util import dt
from tests.components.august.mocks import (
MockActivity,
MockAugustComponentData,
MockAugustComponentDoorBinarySensor,
_mock_august_lock,
)
def test__sync_door_activity_doored_via_dooropen():
"""Test _sync_door_activity dooropen."""
data = MockAugustComponentData(last_door_state_update_timestamp=1)
lock = _mock_august_lock()
data.set_mocked_locks([lock])
door = MockAugustComponentDoorBinarySensor(data, "door_open", lock)
door_activity_start_timestamp = 1234
door_activity = MockActivity(
action=ACTION_DOOR_OPEN,
activity_start_timestamp=door_activity_start_timestamp,
activity_end_timestamp=5678,
)
door._sync_door_activity(door_activity)
assert door.last_update_door_state["door_state"] == LockDoorStatus.OPEN
assert door.last_update_door_state["activity_start_time_utc"] == dt.as_utc(
datetime.datetime.fromtimestamp(door_activity_start_timestamp)
)
def test__sync_door_activity_doorclosed():
"""Test _sync_door_activity doorclosed."""
data = MockAugustComponentData(last_door_state_update_timestamp=1)
lock = _mock_august_lock()
data.set_mocked_locks([lock])
door = MockAugustComponentDoorBinarySensor(data, "door_open", lock)
door_activity_timestamp = 1234
door_activity = MockActivity(
action=ACTION_DOOR_CLOSED,
activity_start_timestamp=door_activity_timestamp,
activity_end_timestamp=door_activity_timestamp,
)
door._sync_door_activity(door_activity)
assert door.last_update_door_state["door_state"] == LockDoorStatus.CLOSED
assert door.last_update_door_state["activity_start_time_utc"] == dt.as_utc(
datetime.datetime.fromtimestamp(door_activity_timestamp)
)
def test__sync_door_activity_ignores_old_data():
"""Test _sync_door_activity dooropen then expired doorclosed."""
data = MockAugustComponentData(last_door_state_update_timestamp=1)
lock = _mock_august_lock()
data.set_mocked_locks([lock])
door = MockAugustComponentDoorBinarySensor(data, "door_open", lock)
first_door_activity_timestamp = 1234
door_activity = MockActivity(
action=ACTION_DOOR_OPEN,
activity_start_timestamp=first_door_activity_timestamp,
activity_end_timestamp=first_door_activity_timestamp,
)
door._sync_door_activity(door_activity)
assert door.last_update_door_state["door_state"] == LockDoorStatus.OPEN
assert door.last_update_door_state["activity_start_time_utc"] == dt.as_utc(
datetime.datetime.fromtimestamp(first_door_activity_timestamp)
)
# Now we do the update with an older start time to
# make sure it ignored
data.set_last_door_state_update_time_utc(
lock.device_id, dt.as_utc(datetime.datetime.fromtimestamp(1000))
)
door_activity_timestamp = 2
door_activity = MockActivity(
action=ACTION_DOOR_CLOSED,
activity_start_timestamp=door_activity_timestamp,
activity_end_timestamp=door_activity_timestamp,
)
door._sync_door_activity(door_activity)
assert door.last_update_door_state["door_state"] == LockDoorStatus.OPEN
assert door.last_update_door_state["activity_start_time_utc"] == dt.as_utc(
datetime.datetime.fromtimestamp(first_door_activity_timestamp)
)
"""The binary_sensor tests for the august platform."""
-1
View File
@@ -128,7 +128,6 @@ def _create_august_data_with_lock_details(lock_details):
authenticator = _mock_august_authenticator()
token_refresh_lock = MagicMock()
api = MagicMock()
api.get_lock_status = MagicMock(return_value=(MagicMock(), MagicMock()))
api.get_lock_detail = MagicMock(side_effect=lock_details)
api.get_operable_locks = MagicMock(return_value=locks)
api.get_doorbells = MagicMock(return_value=[])
+33 -97
View File
@@ -1,110 +1,46 @@
"""The lock tests for the august platform."""
import datetime
from august.activity import (
ACTION_LOCK_LOCK,
ACTION_LOCK_ONETOUCHLOCK,
ACTION_LOCK_UNLOCK,
from homeassistant.components.lock import DOMAIN as LOCK_DOMAIN
from homeassistant.const import (
ATTR_ENTITY_ID,
SERVICE_UNLOCK,
STATE_LOCKED,
STATE_ON,
STATE_UNLOCKED,
)
from august.lock import LockStatus
from homeassistant.util import dt
from tests.components.august.mocks import (
MockActivity,
MockAugustComponentData,
MockAugustComponentLock,
_mock_august_lock,
_create_august_with_devices,
_mock_lock_from_fixture,
)
def test__sync_lock_activity_locked_via_onetouchlock():
"""Test _sync_lock_activity locking."""
lock = _mocked_august_component_lock()
lock_activity_start_timestamp = 1234
lock_activity = MockActivity(
action=ACTION_LOCK_ONETOUCHLOCK,
activity_start_timestamp=lock_activity_start_timestamp,
activity_end_timestamp=5678,
async def test_one_lock_unlock_happy_path(hass):
"""Test creation of a lock with doorsense and bridge."""
lock_one = await _mock_lock_from_fixture(
hass, "get_lock.online_with_doorsense.json"
)
lock._sync_lock_activity(lock_activity)
assert lock.last_update_lock_status["lock_status"] == LockStatus.LOCKED
assert lock.last_update_lock_status["activity_start_time_utc"] == dt.as_utc(
datetime.datetime.fromtimestamp(lock_activity_start_timestamp)
lock_details = [lock_one]
await _create_august_with_devices(hass, lock_details=lock_details)
lock_abc_name = hass.states.get("lock.abc_name")
assert lock_abc_name.state == STATE_LOCKED
assert lock_abc_name.attributes.get("battery_level") == 92
assert lock_abc_name.attributes.get("friendly_name") == "ABC Name"
data = {}
data[ATTR_ENTITY_ID] = "lock.abc_name"
assert await hass.services.async_call(
LOCK_DOMAIN, SERVICE_UNLOCK, data, blocking=True
)
lock_abc_name = hass.states.get("lock.abc_name")
assert lock_abc_name.state == STATE_UNLOCKED
def test__sync_lock_activity_locked_via_lock():
"""Test _sync_lock_activity locking."""
lock = _mocked_august_component_lock()
lock_activity_start_timestamp = 1234
lock_activity = MockActivity(
action=ACTION_LOCK_LOCK,
activity_start_timestamp=lock_activity_start_timestamp,
activity_end_timestamp=5678,
)
lock._sync_lock_activity(lock_activity)
assert lock.last_update_lock_status["lock_status"] == LockStatus.LOCKED
assert lock.last_update_lock_status["activity_start_time_utc"] == dt.as_utc(
datetime.datetime.fromtimestamp(lock_activity_start_timestamp)
)
assert lock_abc_name.attributes.get("battery_level") == 92
assert lock_abc_name.attributes.get("friendly_name") == "ABC Name"
def test__sync_lock_activity_unlocked():
"""Test _sync_lock_activity unlocking."""
lock = _mocked_august_component_lock()
lock_activity_timestamp = 1234
lock_activity = MockActivity(
action=ACTION_LOCK_UNLOCK,
activity_start_timestamp=lock_activity_timestamp,
activity_end_timestamp=lock_activity_timestamp,
)
lock._sync_lock_activity(lock_activity)
assert lock.last_update_lock_status["lock_status"] == LockStatus.UNLOCKED
assert lock.last_update_lock_status["activity_start_time_utc"] == dt.as_utc(
datetime.datetime.fromtimestamp(lock_activity_timestamp)
)
def test__sync_lock_activity_ignores_old_data():
"""Test _sync_lock_activity unlocking."""
data = MockAugustComponentData(last_lock_status_update_timestamp=1)
august_lock = _mock_august_lock()
data.set_mocked_locks([august_lock])
lock = MockAugustComponentLock(data, august_lock)
first_lock_activity_timestamp = 1234
lock_activity = MockActivity(
action=ACTION_LOCK_UNLOCK,
activity_start_timestamp=first_lock_activity_timestamp,
activity_end_timestamp=first_lock_activity_timestamp,
)
lock._sync_lock_activity(lock_activity)
assert lock.last_update_lock_status["lock_status"] == LockStatus.UNLOCKED
assert lock.last_update_lock_status["activity_start_time_utc"] == dt.as_utc(
datetime.datetime.fromtimestamp(first_lock_activity_timestamp)
)
# Now we do the update with an older start time to
# make sure it ignored
data.set_last_lock_status_update_time_utc(
august_lock.device_id, dt.as_utc(datetime.datetime.fromtimestamp(1000))
)
lock_activity_timestamp = 2
lock_activity = MockActivity(
action=ACTION_LOCK_LOCK,
activity_start_timestamp=lock_activity_timestamp,
activity_end_timestamp=lock_activity_timestamp,
)
lock._sync_lock_activity(lock_activity)
assert lock.last_update_lock_status["lock_status"] == LockStatus.UNLOCKED
assert lock.last_update_lock_status["activity_start_time_utc"] == dt.as_utc(
datetime.datetime.fromtimestamp(first_lock_activity_timestamp)
)
def _mocked_august_component_lock():
data = MockAugustComponentData(last_lock_status_update_timestamp=1)
august_lock = _mock_august_lock()
data.set_mocked_locks([august_lock])
return MockAugustComponentLock(data, august_lock)
binary_sensor_abc_name = hass.states.get("binary_sensor.abc_name_open")
assert binary_sensor_abc_name.state == STATE_ON