async def test_async_get_lock_detail_bridge_online(self, mock):
mock.get(
API_GET_LOCK_URL.format(lock_id="A6697750D607098BAE8D6BAA11EF8063"),
body=load_fixture("get_lock.online.json"),
)
api = ApiAsync(ClientSession())
lock = await api.async_get_lock_detail(
ACCESS_TOKEN, "A6697750D607098BAE8D6BAA11EF8063"
)
self.assertEqual("A6697750D607098BAE8D6BAA11EF8063", lock.device_id)
self.assertEqual("Front Door Lock", lock.device_name)
self.assertEqual("000000000000", lock.house_id)
self.assertEqual("X2FSW05DGA", lock.serial_number)
self.assertEqual("109717e9-3.0.44-3.0.30", lock.firmware_version)
self.assertEqual(88, lock.battery_level)
self.assertEqual("AUG-SL02-M02-S02", lock.model)
self.assertEqual("Medium", lock.keypad.battery_level)
self.assertEqual(60, lock.keypad.battery_percentage)
self.assertEqual("5bc65c24e6ef2a263e1450a8", lock.keypad.device_id)
self.assertIsInstance(lock.bridge, BridgeDetail)
self.assertEqual(True, lock.bridge_is_online)
self.assertEqual(True, lock.bridge.operative)
self.assertEqual(True, lock.doorsense)
self.assertEqual(lock.bridge.hyper_bridge, False)
self.assertEqual(LockStatus.LOCKED, lock.lock_status)
self.assertEqual(LockDoorStatus.CLOSED, lock.door_state)
self.assertEqual(
dateutil.parser.parse("2017-12-10T04:48:30.272Z"), lock.lock_status_datetime
)
self.assertEqual(
dateutil.parser.parse("2017-12-10T04:48:30.272Z"), lock.door_state_datetime
)
async def test_async_get_doorbells(self, mock):
mock.get(API_GET_DOORBELLS_URL, body=load_fixture("get_doorbells.json"))
api = ApiAsync(ClientSession())
doorbells = sorted(
await api.async_get_doorbells(ACCESS_TOKEN), key=lambda d: d.device_id
)
self.assertEqual(2, len(doorbells))
first = doorbells[0]
self.assertEqual("1KDAbJH89XYZ", first.device_id)
self.assertEqual("aaaaR08888", first.serial_number)
self.assertEqual("Back Door", first.device_name)
self.assertEqual("doorbell_call_status_offline", first.status)
self.assertEqual(False, first.has_subscription)
self.assertEqual(None, first.image_url)
self.assertEqual("3dd2accadddd", first.house_id)
second = doorbells[1]
self.assertEqual("K98GiDT45GUL", second.device_id)
self.assertEqual("tBXZR0Z35E", second.serial_number)
self.assertEqual("Front Door", second.device_name)
self.assertEqual("doorbell_call_status_online", second.status)
self.assertEqual(True, second.has_subscription)
self.assertEqual("https://image.com/vmk16naaaa7ibuey7sar.jpg", second.image_url)
self.assertEqual("3dd2accaea08", second.house_id)
async def test_async_unlock_return_activities_from_fixture(self, mock):
lock_id = 1234
mock.put(
API_UNLOCK_URL.format(lock_id=lock_id),
body=load_fixture("unlock.json"),
)
api = ApiAsync(ClientSession())
activities = await api.async_unlock_return_activities(ACCESS_TOKEN, lock_id)
expected_unlock_dt = (
dateutil.parser.parse("2020-02-19T19:44:26.745Z")
.astimezone(tz=tzlocal())
.replace(tzinfo=None)
)
self.assertEqual(len(activities), 2)
self.assertIsInstance(activities[0], yalexs.activity.LockOperationActivity)
self.assertEqual(activities[0].device_id, "ABC")
self.assertEqual(activities[0].device_type, "lock")
self.assertEqual(activities[0].action, "unlock")
self.assertEqual(activities[0].activity_start_time, expected_unlock_dt)
self.assertEqual(activities[0].activity_end_time, expected_unlock_dt)
self.assertIsInstance(activities[1], yalexs.activity.DoorOperationActivity)
self.assertEqual(activities[1].device_id, "ABC")
self.assertEqual(activities[1].device_type, "lock")
self.assertEqual(activities[1].action, "doorclosed")
self.assertEqual(activities[1].activity_start_time, expected_unlock_dt)
self.assertEqual(activities[1].activity_end_time, expected_unlock_dt)
async def test_async_get_lock_detail_with_doorsense_disabled_bridge_online(
self, mock
):
mock.get(
API_GET_LOCK_URL.format(lock_id="ABC"),
body=load_fixture("get_lock.online_with_doorsense_disabled.json"),
)
api = ApiAsync(ClientSession())
lock = await api.async_get_lock_detail(ACCESS_TOKEN, "ABC")
self.assertEqual("ABC", lock.device_id)
self.assertEqual("Online door with doorsense disabled", lock.device_name)
self.assertEqual("123", lock.house_id)
self.assertEqual("XY", lock.serial_number)
self.assertEqual("undefined-4.3.0-1.8.14", lock.firmware_version)
self.assertEqual(92, lock.battery_level)
self.assertEqual("AUG-MD01", lock.model)
self.assertEqual(lock.bridge.hyper_bridge, True)
self.assertEqual(None, lock.keypad)
self.assertIsInstance(lock.bridge, BridgeDetail)
self.assertIsInstance(lock.bridge.status, BridgeStatusDetail)
self.assertEqual(BridgeStatus.ONLINE, lock.bridge.status.current)
self.assertEqual(True, lock.bridge_is_online)
self.assertEqual(True, lock.bridge.operative)
self.assertEqual(False, lock.doorsense)
self.assertEqual(LockStatus.LOCKED, lock.lock_status)
self.assertEqual(LockDoorStatus.DISABLED, lock.door_state)
self.assertEqual(
dateutil.parser.parse("2017-12-10T04:48:30.272Z"), lock.lock_status_datetime
)
self.assertEqual(
dateutil.parser.parse("2017-12-10T04:48:30.272Z"), lock.door_state_datetime
)
async def test_async_get_pins(self, mock):
lock_id = 1234
mock.get(
API_GET_PINS_URL.format(lock_id=lock_id),
body=load_fixture("get_pins.json"),
)
api = ApiAsync(ClientSession())
pins = await api.async_get_pins(ACCESS_TOKEN, lock_id)
self.assertEqual(1, len(pins))
first = pins[0]
self.assertEqual("epoZ87XSPqxlFdsaYyJiRRVR", first.pin_id)
self.assertEqual("A6697750D607098BAE8D6BAA11EF8063", first.lock_id)
self.assertEqual("c3b3a94f-473z-61a3-a8d1-a6e99482787a", first.user_id)
self.assertEqual("in-use", first.state)
self.assertEqual("123456", first.pin)
self.assertEqual(646545456465161, first.slot)
self.assertEqual("one-time", first.access_type)
self.assertEqual("John", first.first_name)
self.assertEqual("Doe", first.last_name)
self.assertEqual(True, first.unverified)
self.assertEqual(utc_of(2016, 11, 26, 22, 27, 11, 176000), first.created_at)
self.assertEqual(utc_of(2017, 11, 23, 00, 42, 19, 470000), first.updated_at)
self.assertEqual(utc_of(2017, 12, 10, 3, 12, 55, 563000), first.loaded_date)
self.assertEqual(utc_of(2018, 1, 1, 1, 1, 1, 563000), first.access_start_time)
self.assertEqual(utc_of(2018, 12, 1, 1, 1, 1, 563000), first.access_end_time)
self.assertEqual(utc_of(2018, 11, 5, 10, 2, 41, 684000), first.access_times)
async def test_async_get_doorbell_detail(self, mock):
expected_doorbell_image_url = "https://image.com/vmk16naaaa7ibuey7sar.jpg"
mock.get(
API_GET_DOORBELL_URL.format(doorbell_id="K98GiDT45GUL"),
body=load_fixture("get_doorbell.json"),
)
mock.get(expected_doorbell_image_url, body="doorbell_image_mocked")
api = ApiAsync(ClientSession())
doorbell = await api.async_get_doorbell_detail(ACCESS_TOKEN, "K98GiDT45GUL")
self.assertEqual("K98GiDT45GUL", doorbell.device_id)
self.assertEqual("Front Door", doorbell.device_name)
self.assertEqual("3dd2accaea08", doorbell.house_id)
self.assertEqual("tBXZR0Z35E", doorbell.serial_number)
self.assertEqual("2.3.0-RC153+201711151527", doorbell.firmware_version)
self.assertEqual("doorbell_call_status_online", doorbell.status)
self.assertEqual(96, doorbell.battery_level)
self.assertEqual("gen1", doorbell.model)
self.assertEqual(True, doorbell.is_online)
self.assertEqual(False, doorbell.is_standby)
self.assertEqual(
dateutil.parser.parse("2017-12-10T08:01:35Z"),
doorbell.image_created_at_datetime,
)
self.assertEqual(True, doorbell.has_subscription)
self.assertEqual(expected_doorbell_image_url, doorbell.image_url)
self.assertEqual(
await doorbell.async_get_doorbell_image(ClientSession()),
b"doorbell_image_mocked",
)
async def test_async_get_doorbell_offline(self, mock):
mock.get(
API_GET_DOORBELL_URL.format(doorbell_id="231ee2168dd0"),
body=load_fixture("get_doorbell.offline.json"),
)
api = ApiAsync(ClientSession())
doorbell = await api.async_get_doorbell_detail(ACCESS_TOKEN, "231ee2168dd0")
self.assertEqual("231ee2168dd0", doorbell.device_id)
self.assertEqual("My Door", doorbell.device_name)
self.assertEqual("houseid", doorbell.house_id)
self.assertEqual("abcd", doorbell.serial_number)
self.assertEqual("3.1.0-HYDRC75+201909251139", doorbell.firmware_version)
self.assertEqual("doorbell_offline", doorbell.status)
self.assertEqual(81, doorbell.battery_level)
self.assertEqual(False, doorbell.is_online)
self.assertEqual(False, doorbell.is_standby)
self.assertEqual(
dateutil.parser.parse("2019-02-20T23:52:46Z"),
doorbell.image_created_at_datetime,
)
self.assertEqual(True, doorbell.has_subscription)
self.assertEqual("https://res.cloudinary.com/x.jpg", doorbell.image_url)
self.assertEqual("hydra1", doorbell.model)
async def test_async_get_lock_detail_bridge_offline(self, mock):
mock.get(
API_GET_LOCK_URL.format(lock_id="ABC"),
body=load_fixture("get_lock.offline.json"),
)
api = ApiAsync(ClientSession())
lock = await api.async_get_lock_detail(ACCESS_TOKEN, "ABC")
self.assertEqual("ABC", lock.device_id)
self.assertEqual("Test", lock.device_name)
self.assertEqual("houseid", lock.house_id)
self.assertEqual("ABC", lock.serial_number)
self.assertEqual("undefined-1.59.0-1.13.2", lock.firmware_version)
self.assertEqual(-100, lock.battery_level)
self.assertEqual("AUG-X", lock.model)
self.assertEqual(False, lock.bridge_is_online)
self.assertEqual(None, lock.keypad)
self.assertEqual(None, lock.bridge)
self.assertEqual(False, lock.doorsense)
self.assertEqual(LockStatus.UNKNOWN, lock.lock_status)
self.assertEqual(LockDoorStatus.DISABLED, lock.door_state)
self.assertEqual(None, lock.lock_status_datetime)
self.assertEqual(None, lock.door_state_datetime)
async def async_setup(self, conf):
"""Create the api and authenticator objects."""
if conf.get(VERIFICATION_CODE_KEY):
return
self._access_token_cache_file = conf.get(
CONF_ACCESS_TOKEN_CACHE_FILE,
f".{conf[CONF_USERNAME]}{DEFAULT_AUGUST_CONFIG_FILE}",
)
self._config = conf
self.api = ApiAsync(
self._aiohttp_session,
timeout=self._config.get(CONF_TIMEOUT, DEFAULT_TIMEOUT),
)
self.authenticator = AuthenticatorAsync(
self.api,
self._config[CONF_LOGIN_METHOD],
self._config[CONF_USERNAME],
self._config.get(CONF_PASSWORD, ""),
install_id=self._config.get(CONF_INSTALL_ID),
access_token_cache_file=self._hass.config.path(
self._access_token_cache_file),
)
await self.authenticator.async_setup_authentication()
async def _async_create_authenticator_async(self, mock_aioresponses):
authenticator = AuthenticatorAsync(ApiAsync(ClientSession()),
"phone",
"user",
"pass",
install_id="install_id")
await authenticator.async_setup_authentication()
return authenticator
async def test_async_lock_async_old_bridge(self, mock):
lock_id = 1234
mock.put(
API_LOCK_ASYNC_URL.format(lock_id=lock_id),
)
api = ApiAsync(ClientSession())
await api.async_lock_async(ACCESS_TOKEN, lock_id, hyper_bridge=False)
async def test_async_refresh_access_token(self, mock):
mock.get(
API_GET_HOUSES_URL, body="{}", headers={"x-august-access-token": "xyz"}
)
api = ApiAsync(ClientSession())
new_token = await api.async_refresh_access_token("token")
assert new_token == "xyz"
async def test_async_lock_from_fixture(self, mock):
lock_id = 1234
mock.put(API_LOCK_URL.format(lock_id=lock_id), body=load_fixture("lock.json"))
api = ApiAsync(ClientSession())
status = await api.async_lock(ACCESS_TOKEN, lock_id)
self.assertEqual(LockStatus.LOCKED, status)
async def test_async_unlock(self, mock):
lock_id = 1234
mock.put(API_UNLOCK_URL.format(lock_id=lock_id), body='{"status": "unlocked"}')
api = ApiAsync(ClientSession())
status = await api.async_unlock(ACCESS_TOKEN, lock_id)
self.assertEqual(LockStatus.UNLOCKED, status)
async def test_async_get_doorbell_gen2_low_battery_detail(self, mock):
mock.get(
API_GET_DOORBELL_URL.format(doorbell_id="did"),
body=load_fixture("get_doorbell.battery_low.json"),
)
api = ApiAsync(ClientSession())
doorbell = await api.async_get_doorbell_detail(ACCESS_TOKEN, "did")
self.assertEqual(10, doorbell.battery_level)
async def test_async_get_lock_door_status_with_closed_response(self, mock):
lock_id = 1234
mock.get(
API_GET_LOCK_STATUS_URL.format(lock_id=lock_id),
body='{"doorState": "kAugLockDoorState_Closed"}',
)
api = ApiAsync(ClientSession())
door_status = await api.async_get_lock_door_status(ACCESS_TOKEN, lock_id)
self.assertEqual(LockDoorStatus.CLOSED, door_status)
async def test_async_get_lock_door_status_with_unknown_response(self, mock):
lock_id = 1234
mock.get(
API_GET_LOCK_STATUS_URL.format(lock_id=lock_id),
body='{"doorState": "not_advertising"}',
)
api = ApiAsync(ClientSession())
door_status = await api.async_get_lock_door_status(ACCESS_TOKEN, lock_id)
self.assertEqual(LockDoorStatus.UNKNOWN, door_status)
async def test_async_get_lock_status_with_unlocked_response(self, mock):
lock_id = 1234
mock.get(
API_GET_LOCK_STATUS_URL.format(lock_id=lock_id),
body='{"status": "kAugLockState_Unlocked"}',
)
api = ApiAsync(ClientSession())
status = await api.async_get_lock_status(ACCESS_TOKEN, lock_id)
self.assertEqual(LockStatus.UNLOCKED, status)
async def test_async_get_operable_locks(self, mock):
mock.get(API_GET_LOCKS_URL, body=load_fixture("get_locks.json"))
api = ApiAsync(ClientSession())
locks = await api.async_get_operable_locks(ACCESS_TOKEN)
self.assertEqual(1, len(locks))
first = locks[0]
self.assertEqual("A6697750D607098BAE8D6BAA11EF8063", first.device_id)
self.assertEqual("Front Door Lock", first.device_name)
self.assertEqual("000000000000", first.house_id)
self.assertEqual(True, first.is_operable)
async def test_async_get_lock_detail_doorsense_init_state(self, mock):
mock.get(
API_GET_LOCK_URL.format(lock_id="A6697750D607098BAE8D6BAA11EF8063"),
body=load_fixture("get_lock.doorsense_init.json"),
)
api = ApiAsync(ClientSession())
lock = await api.async_get_lock_detail(
ACCESS_TOKEN, "A6697750D607098BAE8D6BAA11EF8063"
)
self.assertEqual("A6697750D607098BAE8D6BAA11EF8063", lock.device_id)
self.assertEqual("Front Door Lock", lock.device_name)
self.assertEqual("000000000000", lock.house_id)
self.assertEqual("X2FSW05DGA", lock.serial_number)
self.assertEqual("109717e9-3.0.44-3.0.30", lock.firmware_version)
self.assertEqual(88, lock.battery_level)
self.assertEqual("Medium", lock.keypad.battery_level)
self.assertEqual("5bc65c24e6ef2a263e1450a8", lock.keypad.device_id)
self.assertEqual("AK-R1", lock.keypad.model)
self.assertEqual("Front Door Lock Keypad", lock.keypad.device_name)
self.assertIsInstance(lock.bridge, BridgeDetail)
self.assertEqual(True, lock.bridge_is_online)
self.assertEqual(True, lock.bridge.operative)
self.assertEqual(False, lock.doorsense)
self.assertEqual(LockStatus.LOCKED, lock.lock_status)
self.assertEqual(LockDoorStatus.DISABLED, lock.door_state)
self.assertEqual(
dateutil.parser.parse("2017-12-10T04:48:30.272Z"), lock.lock_status_datetime
)
self.assertEqual(
dateutil.parser.parse("2017-12-10T04:48:30.272Z"), lock.door_state_datetime
)
lock.lock_status = LockStatus.UNLOCKED
self.assertEqual(LockStatus.UNLOCKED, lock.lock_status)
lock.door_state = LockDoorStatus.OPEN
self.assertEqual(LockDoorStatus.OPEN, lock.door_state)
lock.lock_status_datetime = dateutil.parser.parse("2020-12-10T04:48:30.272Z")
self.assertEqual(
dateutil.parser.parse("2020-12-10T04:48:30.272Z"), lock.lock_status_datetime
)
lock.door_state_datetime = dateutil.parser.parse("2019-12-10T04:48:30.272Z")
self.assertEqual(
dateutil.parser.parse("2019-12-10T04:48:30.272Z"), lock.door_state_datetime
)
assert isinstance(lock.raw, dict)
async def test_async_lock(self, mock):
lock_id = 1234
mock.put(
API_LOCK_URL.format(lock_id=lock_id),
body='{"status":"locked",'
'"dateTime":"2017-12-10T07:43:39.056Z",'
'"isLockStatusChanged":false,'
'"valid":true}',
)
api = ApiAsync(ClientSession())
status = await api.async_lock(ACCESS_TOKEN, lock_id)
self.assertEqual(LockStatus.LOCKED, status)
async def test_async_get_lock_and_door_status_with_open_response(self, mock):
lock_id = 1234
mock.get(
API_GET_LOCK_STATUS_URL.format(lock_id=lock_id),
body='{"status": "kAugLockState_Unlocked"'
',"doorState": "kAugLockDoorState_Open"}',
)
api = ApiAsync(ClientSession())
door_status, status = await api.async_get_lock_door_status(
ACCESS_TOKEN, lock_id, True
)
self.assertEqual(LockDoorStatus.OPEN, door_status)
self.assertEqual(LockStatus.UNLOCKED, status)
async def test_async_validate_verification_code(self, mock):
last_args = {}
def response_callback(url, **kwargs):
last_args.update(kwargs)
return CallbackResult(status=200, body="{}")
mock.post(
API_VALIDATE_VERIFICATION_CODE_URLS["email"], callback=response_callback
)
api = ApiAsync(ClientSession())
await api.async_validate_verification_code(
ACCESS_TOKEN, "email", "emailaddress", 123456
)
assert last_args["json"] == {"code": "123456", "email": "emailaddress"}
async def test_async_get_locks(self, mock):
mock.get(API_GET_LOCKS_URL, body=load_fixture("get_locks.json"))
api = ApiAsync(ClientSession())
locks = sorted(
await api.async_get_locks(ACCESS_TOKEN), key=lambda d: d.device_id
)
self.assertEqual(2, len(locks))
first = locks[0]
self.assertEqual("A6697750D607098BAE8D6BAA11EF8063", first.device_id)
self.assertEqual("Front Door Lock", first.device_name)
self.assertEqual("000000000000", first.house_id)
self.assertEqual(True, first.is_operable)
second = locks[1]
self.assertEqual("A6697750D607098BAE8D6BAA11EF9999", second.device_id)
self.assertEqual("Back Door Lock", second.device_name)
self.assertEqual("000000000011", second.house_id)
self.assertEqual(False, second.is_operable)
async def test_async_get_doorbell_detail_missing_image(self, mock):
mock.get(
API_GET_DOORBELL_URL.format(doorbell_id="K98GiDT45GUL"),
body=load_fixture("get_doorbell_missing_image.json"),
)
api = ApiAsync(ClientSession())
doorbell = await api.async_get_doorbell_detail(ACCESS_TOKEN, "K98GiDT45GUL")
self.assertEqual("K98GiDT45GUL", doorbell.device_id)
self.assertEqual("Front Door", doorbell.device_name)
self.assertEqual("3dd2accaea08", doorbell.house_id)
self.assertEqual("tBXZR0Z35E", doorbell.serial_number)
self.assertEqual("2.3.0-RC153+201711151527", doorbell.firmware_version)
self.assertEqual("doorbell_call_status_online", doorbell.status)
self.assertEqual(96, doorbell.battery_level)
self.assertEqual(True, doorbell.is_online)
self.assertEqual(False, doorbell.is_standby)
self.assertEqual(None, doorbell.image_created_at_datetime)
self.assertEqual(True, doorbell.has_subscription)
self.assertEqual(None, doorbell.image_url)
async def test_async_get_house_activities(self, mock):
house_id = 1234
mock.get(
API_GET_HOUSE_ACTIVITIES_URL.format(house_id=house_id) + "?limit=8",
body=load_fixture("get_house_activities.json"),
)
api = ApiAsync(ClientSession())
activities = await api.async_get_house_activities(ACCESS_TOKEN, house_id)
self.assertEqual(10, len(activities))
self.assertIsInstance(activities[0], yalexs.activity.LockOperationActivity)
self.assertIsInstance(activities[1], yalexs.activity.LockOperationActivity)
self.assertIsInstance(activities[2], yalexs.activity.LockOperationActivity)
self.assertIsInstance(activities[3], yalexs.activity.LockOperationActivity)
self.assertIsInstance(activities[4], yalexs.activity.LockOperationActivity)
self.assertIsInstance(activities[5], yalexs.activity.DoorOperationActivity)
self.assertIsInstance(activities[6], yalexs.activity.DoorOperationActivity)
self.assertIsInstance(activities[7], yalexs.activity.DoorOperationActivity)
self.assertIsInstance(activities[8], yalexs.activity.LockOperationActivity)
self.assertIsInstance(activities[9], yalexs.activity.LockOperationActivity)
async def test_async_get_v2_lock_detail_bridge_online(self, mock):
mock.get(
API_GET_LOCK_URL.format(lock_id="snip"),
body=load_fixture("get_lock_v2.online.json"),
)
api = ApiAsync(ClientSession())
lock = await api.async_get_lock_detail(ACCESS_TOKEN, "snip")
self.assertEqual("snip", lock.device_id)
self.assertEqual("Front Door", lock.device_name)
self.assertEqual("snip", lock.house_id)
self.assertEqual("snip", lock.serial_number)
self.assertEqual("3.0.44-3.0.29", lock.firmware_version)
self.assertEqual(96, lock.battery_level)
self.assertEqual("AUG-SL02-M02-S02", lock.model)
self.assertIsInstance(lock.bridge, BridgeDetail)
self.assertEqual(True, lock.bridge_is_online)
self.assertEqual(True, lock.bridge.operative)
self.assertEqual(False, lock.doorsense)
self.assertEqual(lock.bridge.hyper_bridge, False)
self.assertEqual(LockStatus.LOCKED, lock.lock_status)
self.assertEqual(LockDoorStatus.DISABLED, lock.door_state)
async def test_async_get_usern(self, mock):
mock.get(API_GET_USER_URL, body='{"UserID": "abc"}')
api = ApiAsync(ClientSession())
user_details = await api.async_get_user("token")
assert user_details == {"UserID": "abc"}
async def test_async_status_async_new_bridge(self, mock):
lock_id = 1234
mock.put(f"{API_STATUS_ASYNC_URL}{HYPER_BRIDGE_PARAM}".format(lock_id=lock_id))
api = ApiAsync(ClientSession())
await api.async_status_async(ACCESS_TOKEN, lock_id)
async def test_async_unlock_async_new_bridge(self, mock):
lock_id = 1234
mock.put(f"{API_UNLOCK_ASYNC_URL}{HYPER_BRIDGE_PARAM}".format(lock_id=lock_id))
api = ApiAsync(ClientSession())
await api.async_unlock_async(ACCESS_TOKEN, lock_id, hyper_bridge=True)
