def test_set_characteristics_with_crypto(driver): """Verify an encrypt characteristics request.""" loop = MagicMock() transport = MagicMock() connections = {} acc = Accessory(driver, "TestAcc", aid=1) assert acc.aid == 1 service = acc.driver.loader.get_service("GarageDoorOpener") acc.add_service(service) driver.add_accessory(acc) hap_proto = hap_protocol.HAPServerProtocol(loop, connections, driver) hap_proto.connection_made(transport) hap_proto.hap_crypto = MockHAPCrypto() hap_proto.handler.is_encrypted = True with patch.object(hap_proto.transport, "write") as writer: hap_proto.data_received( b'PUT /characteristics HTTP/1.1\r\nHost: HASS12\\032AD1C22._hap._tcp.local\r\nContent-Length: 49\r\nContent-Type: application/hap+json\r\n\r\n{"characteristics":[{"aid":1,"iid":9,"ev":true}]}' # pylint: disable=line-too-long ) hap_proto.close() assert writer.call_args_list[0][0][0] == b"HTTP/1.1 204 No Content\r\n\r\n"
def test_bridge_add_accessory(mock_driver): bridge = Bridge(mock_driver, "Test Bridge") acc = Accessory(mock_driver, "Test Accessory", aid=2) bridge.add_accessory(acc) acc2 = Accessory(mock_driver, "Test Accessory 2") bridge.add_accessory(acc2) assert acc2.aid != STANDALONE_AID and acc2.aid != acc.aid
def test_acc_add_preload_service_with_chars(mock_driver): """Test method add_preload_service with additional chars.""" acc = Accessory(mock_driver, "Test Accessory") serv = acc.add_preload_service("Television", chars=["ActiveIdentifier"]) assert isinstance(serv, Service) assert serv.get_characteristic("ActiveIdentifier") is not None
def test_get_characteristics_with_crypto(driver): """Verify an encrypt characteristics request.""" loop = MagicMock() transport = MagicMock() connections = {} acc = Accessory(driver, "TestAcc", aid=1) assert acc.aid == 1 service = acc.driver.loader.get_service("TemperatureSensor") acc.add_service(service) driver.add_accessory(acc) hap_proto = hap_protocol.HAPServerProtocol(loop, connections, driver) hap_proto.connection_made(transport) hap_proto.hap_crypto = MockHAPCrypto() hap_proto.handler.is_encrypted = True with patch.object(hap_proto.transport, "write") as writer: hap_proto.data_received( b"GET /characteristics?id=3762173001.7 HTTP/1.1\r\nHost: HASS\\032Bridge\\032YPHW\\032B223AD._hap._tcp.local\r\n\r\n" # pylint: disable=line-too-long ) hap_proto.data_received( b"GET /characteristics?id=1.5 HTTP/1.1\r\nHost: HASS\\032Bridge\\032YPHW\\032B223AD._hap._tcp.local\r\n\r\n" # pylint: disable=line-too-long ) hap_proto.close() assert b"Content-Length:" in writer.call_args_list[0][0][0] assert b"Transfer-Encoding: chunked\r\n\r\n" not in writer.call_args_list[0][0][0] assert b"-70402" in writer.call_args_list[0][0][0] assert b"Content-Length:" in writer.call_args_list[1][0][0] assert b"Transfer-Encoding: chunked\r\n\r\n" not in writer.call_args_list[1][0][0] assert b"TestAcc" in writer.call_args_list[1][0][0]
def test_bridge_n_add_accessory_dup_aid(mock_driver): bridge = Bridge(mock_driver, "Test Bridge") acc_1 = Accessory(mock_driver, "Test Accessory 1", aid=2) acc_2 = Accessory(mock_driver, "Test Accessory 2", aid=acc_1.aid) bridge.add_accessory(acc_1) with pytest.raises(ValueError): bridge.add_accessory(acc_2)
def __init__(self, serial_no=uuid.uuid4(), display_name=None, channel_interface_serial_no=None, data_transformer=None, config=None, *args, **kwargs): ABC.__init__(self) self.display_name = self.set_display_name(display_name) self.serial_no = serial_no self.channel_serial_no = channel_interface_serial_no self.channel = id_channels_map[str(self.channel_serial_no)] Accessory.__init__(self, driver=driver, display_name=self.display_name, *args, **kwargs) self.service = self.add_functional_service() self.char = self.add_functional_service_characteristic() if config is not None and 'datatransformer' in config.keys(): self.data_transformer = config['datatransformer'] if config is not None and 'data_transformer' in config.keys(): self.data_transformer = config['data_transformer']
async def test_camera_snapshot_times_out(driver): """Test camera snapshot times out.""" loop = MagicMock() transport = MagicMock() connections = {} def _get_snapshot(*_): raise asyncio.TimeoutError("timeout") acc = Accessory(driver, "TestAcc") acc.get_snapshot = _get_snapshot driver.add_accessory(acc) hap_proto = hap_protocol.HAPServerProtocol(loop, connections, driver) hap_proto.connection_made(transport) hap_proto.hap_crypto = MockHAPCrypto() hap_proto.handler.is_encrypted = True with patch.object(hap_proto.transport, "write") as writer: hap_proto.data_received( b'POST /resource HTTP/1.1\r\nHost: HASS\\032Bridge\\032BROZ\\0323BF435._hap._tcp.local\r\nContent-Length: 79\r\nContent-Type: application/hap+json\r\n\r\n{"image-height":360,"resource-type":"image","image-width":640,"aid":1411620844}' # pylint: disable=line-too-long ) try: await hap_proto.response.task except Exception: # pylint: disable=broad-except pass await asyncio.sleep(0) assert b"-70402" in writer.call_args_list[0][0][0] hap_proto.close()
def test_handle_get_characteristics_encrypted(driver): """Verify an encrypted get_characteristics.""" acc = Accessory(driver, "TestAcc", aid=1) assert acc.aid == 1 service = acc.driver.loader.get_service("GarageDoorOpener") acc.add_service(service) driver.add_accessory(acc) handler = hap_handler.HAPServerHandler(driver, "peername") handler.is_encrypted = True response = hap_handler.HAPResponse() handler.response = response handler.path = "/characteristics?id=1.9" handler.handle_get_characteristics() assert response.status_code == 207 assert b'"value": 0' in response.body with patch.object(acc.iid_manager, "get_obj", side_effect=CharacteristicError): response = hap_handler.HAPResponse() handler.response = response handler.path = "/characteristics?id=1.9" handler.handle_get_characteristics() assert response.status_code == 207 assert b"-70402" in response.body
async def test_camera_snapshot_works_async(driver): """Test camera snapshot works if there is support for it.""" loop = MagicMock() transport = MagicMock() connections = {} async def _async_get_snapshot(*_): return b"fakesnap" acc = Accessory(driver, "TestAcc") acc.async_get_snapshot = _async_get_snapshot driver.add_accessory(acc) hap_proto = hap_protocol.HAPServerProtocol(loop, connections, driver) hap_proto.connection_made(transport) hap_proto.hap_crypto = MockHAPCrypto() hap_proto.handler.is_encrypted = True with patch.object(hap_proto.transport, "write") as writer: hap_proto.data_received( b'POST /resource HTTP/1.1\r\nHost: HASS\\032Bridge\\032BROZ\\0323BF435._hap._tcp.local\r\nContent-Length: 79\r\nContent-Type: application/hap+json\r\n\r\n{"image-height":360,"resource-type":"image","image-width":640,"aid":1411620844}' # pylint: disable=line-too-long ) await hap_proto.response.task await asyncio.sleep(0) assert b"fakesnap" in writer.call_args_list[0][0][0] hap_proto.close()
def test_set_info_service(mock_driver): acc_1 = Accessory(mock_driver, "Test Accessory 1", aid=2) acc_1.set_info_service("firmware", "manufacturer", "model", "serial") serv_info = acc_1.get_service("AccessoryInformation") assert serv_info.get_characteristic("FirmwareRevision").value == "firmware" assert serv_info.get_characteristic("Manufacturer").value == "manufacturer" assert serv_info.get_characteristic("Model").value == "model" assert serv_info.get_characteristic("SerialNumber").value == "serial"
def test_set_info_service_invalid_serial(mock_driver): acc_1 = Accessory(mock_driver, "Test Accessory 1", aid=2) acc_1.set_info_service(serial_number="") serv_info = acc_1.get_service("AccessoryInformation") assert serv_info.get_characteristic("FirmwareRevision").value == "" assert serv_info.get_characteristic("Manufacturer").value == "" assert serv_info.get_characteristic("Model").value == "" assert serv_info.get_characteristic("SerialNumber").value == "default"
def test_identify(): callback = AsyncMock() accessory = Accessory(name='test_name', model='test_model', manufacturer='test_manufacturer', identify_callback=callback) asyncio.get_event_loop().run_until_complete(accessory.identify()) callback.assert_called_once()
def test_setup_message_without_qr_code(mock_stdout, mock_driver): """Verify we print out the setup code.""" acc = Accessory(mock_driver, "Test Accessory", aid=STANDALONE_AID) mock_driver.state = State( address="1.2.3.4", mac="AA::BB::CC::DD::EE", pincode=b"653-32-1211", port=44 ) with patch.object(accessory, "SUPPORT_QR_CODE", False): acc.setup_message() assert "653-32-1211" in mock_stdout.getvalue()
async def test_bridge_run_stop(mock_driver): mock_driver.async_add_job = AsyncMock() bridge = Bridge(mock_driver, "Test Bridge") acc = Accessory(mock_driver, "Test Accessory", aid=2) assert acc.available is True bridge.add_accessory(acc) acc2 = Accessory(mock_driver, "Test Accessory 2") bridge.add_accessory(acc2) await bridge.run() assert mock_driver.async_add_job.called await bridge.stop()
def test_xhm_uri(mock_driver): acc_1 = Accessory(mock_driver, "Test Accessory 1", aid=2) acc_1.category = CATEGORY_CAMERA mock_driver.state = State(address="1.2.3.4", mac="AA::BB::CC::DD::EE", pincode=b"653-32-1211", port=44) mock_driver.state.setup_id = "AAAA" assert acc_1.xhm_uri() == "X-HM://00H708WSBAAAA" acc_1.category = CATEGORY_TELEVISION mock_driver.state = State(address="1.2.3.4", mac="AA::BB::CC::DD::EE", pincode=b"323-23-1212", port=44) mock_driver.state.setup_id = "BBBB" assert acc_1.xhm_uri() == "X-HM://00UQBOTF0BBBB" acc_1.category = CATEGORY_TARGET_CONTROLLER mock_driver.state = State(address="1.2.3.4", mac="AA::BB::CC::DD::EE", pincode=b"323-23-1212", port=44) mock_driver.state.setup_id = "BBBB" assert acc_1.xhm_uri() == "X-HM://00VPU8UEKBBBB"
def test_add_pairing(driver): """Verify an encrypted add pairing request.""" driver.add_accessory(Accessory(driver, "TestAcc")) handler = hap_handler.HAPServerHandler(driver, "peername") handler.is_encrypted = True response = hap_handler.HAPResponse() handler.response = response handler.request_body = tlv.encode( hap_handler.HAP_TLV_TAGS.REQUEST_TYPE, hap_handler.HAP_TLV_STATES.M3, hap_handler.HAP_TLV_TAGS.USERNAME, str(CLIENT_UUID).encode("utf-8"), hap_handler.HAP_TLV_TAGS.PUBLIC_KEY, PUBLIC_KEY, hap_handler.HAP_TLV_TAGS.PERMISSIONS, hap_handler.HAP_PERMISSIONS.ADMIN, ) assert driver.state.paired is False handler.handle_pairings() assert tlv.decode(response.body) == { hap_handler.HAP_TLV_TAGS.SEQUENCE_NUM: hap_handler.HAP_TLV_STATES.M2 } assert driver.state.paired is True assert CLIENT_UUID in driver.state.paired_clients
def test_list_pairings(driver): """Verify an encrypted list pairings request.""" driver.add_accessory(Accessory(driver, "TestAcc")) handler = hap_handler.HAPServerHandler(driver, "peername") handler.is_encrypted = True driver.pair( CLIENT_UUID, PUBLIC_KEY, ) assert CLIENT_UUID in driver.state.paired_clients response = hap_handler.HAPResponse() handler.response = response handler.request_body = tlv.encode(hap_handler.HAP_TLV_TAGS.REQUEST_TYPE, hap_handler.HAP_TLV_STATES.M5) handler.handle_pairings() tlv_objects = tlv.decode(response.body) assert tlv_objects == { hap_handler.HAP_TLV_TAGS.SEQUENCE_NUM: hap_handler.HAP_TLV_STATES.M2, hap_handler.HAP_TLV_TAGS.USERNAME: str(CLIENT_UUID).encode("utf8"), hap_handler.HAP_TLV_TAGS.PUBLIC_KEY: PUBLIC_KEY, hap_handler.HAP_TLV_TAGS.PERMISSIONS: hap_handler.HAP_PERMISSIONS.ADMIN, }
def test_invalid_pairing_three(driver): """Verify we respond with error with invalid request.""" driver.add_accessory(Accessory(driver, "TestAcc")) handler = hap_handler.HAPServerHandler(driver, "peername") handler.is_encrypted = False response = hap_handler.HAPResponse() handler.response = response handler.request_body = tlv.encode( hap_handler.HAP_TLV_TAGS.SEQUENCE_NUM, hap_handler.HAP_TLV_STATES.M5, hap_handler.HAP_TLV_TAGS.ENCRYPTED_DATA, b"", ) handler.accessory_handler.setup_srp_verifier() handler.accessory_handler.srp_verifier.set_A(b"") handler.handle_pairing() tlv_objects = tlv.decode(response.body) assert tlv_objects == { hap_handler.HAP_TLV_TAGS.SEQUENCE_NUM: hap_handler.HAP_TLV_STATES.M6, hap_handler.HAP_TLV_TAGS.ERROR_CODE: hap_handler.HAP_TLV_ERRORS.AUTHENTICATION, }
def test_attempt_to_pair_when_already_paired(driver): """Verify we respond with unavailable if already paired.""" driver.add_accessory(Accessory(driver, "TestAcc")) handler = hap_handler.HAPServerHandler(driver, "peername") handler.is_encrypted = False driver.pair( CLIENT_UUID, PUBLIC_KEY, ) response = hap_handler.HAPResponse() handler.response = response handler.request_body = tlv.encode( hap_handler.HAP_TLV_TAGS.SEQUENCE_NUM, hap_handler.HAP_TLV_STATES.M1, ) handler.handle_pairing() tlv_objects = tlv.decode(response.body) assert tlv_objects == { hap_handler.HAP_TLV_TAGS.SEQUENCE_NUM: hap_handler.HAP_TLV_STATES.M2, hap_handler.HAP_TLV_TAGS.ERROR_CODE: hap_handler.HAP_TLV_ERRORS.UNAVAILABLE, }
def test_list_pairings_unencrypted(driver): """Verify an unencrypted list pairings request fails.""" driver.add_accessory(Accessory(driver, "TestAcc")) handler = hap_handler.HAPServerHandler(driver, "peername") handler.is_encrypted = False driver.pair( CLIENT_UUID, PUBLIC_KEY, ) assert CLIENT_UUID in driver.state.paired_clients response = hap_handler.HAPResponse() handler.response = response handler.request_body = tlv.encode(hap_handler.HAP_TLV_TAGS.REQUEST_TYPE, hap_handler.HAP_TLV_STATES.M5) handler.handle_pairings() tlv_objects = tlv.decode(response.body) assert tlv_objects == { hap_handler.HAP_TLV_TAGS.SEQUENCE_NUM: hap_handler.HAP_TLV_STATES.M2, hap_handler.HAP_TLV_TAGS.ERROR_CODE: hap_handler.HAP_TLV_ERRORS.AUTHENTICATION, }
def test_invalid_content_length(driver): """Test we handle invalid content length.""" loop = MagicMock() transport = MagicMock() connections = {} driver.add_accessory(Accessory(driver, "TestAcc")) hap_proto = hap_protocol.HAPServerProtocol(loop, connections, driver) hap_proto.connection_made(transport) with patch.object(hap_proto.transport, "write") as writer: hap_proto.data_received( b"POST /pair-setup HTTP/1.0\r\nConnection:close\r\nHost: Bridge\\032C77C47._hap._tcp.local\r\nContent-Length: 2\r\nContent-Type: application/pairing+tlv8\r\n\r\n\x00\x01\x00\x06\x01\x01" # pylint: disable=line-too-long ) hap_proto.data_received( b"POST /pair-setup HTTP/1.0\r\nConnection:close\r\nHost: Bridge\\032C77C47._hap._tcp.local\r\nContent-Length: 2\r\nContent-Type: application/pairing+tlv8\r\n\r\n\x00\x01\x00\x06\x01\x01" # pylint: disable=line-too-long ) assert ( writer.call_args_list[0][0][0].startswith( b"HTTP/1.1 500 Internal Server Error\r\n" ) is True ) assert len(writer.call_args_list) == 1 assert connections == {} hap_proto.close()
def test_pair_verify_one(driver): """Verify an unencrypted pair verify one.""" driver.add_accessory(Accessory(driver, "TestAcc")) handler = hap_handler.HAPServerHandler(driver, "peername") handler.is_encrypted = False driver.pair( CLIENT_UUID, PUBLIC_KEY, ) assert CLIENT_UUID in driver.state.paired_clients response = hap_handler.HAPResponse() handler.response = response handler.request_body = tlv.encode( hap_handler.HAP_TLV_TAGS.SEQUENCE_NUM, hap_handler.HAP_TLV_STATES.M1, hap_handler.HAP_TLV_TAGS.PUBLIC_KEY, PUBLIC_KEY, ) handler.handle_pair_verify() tlv_objects = tlv.decode(response.body) assert (tlv_objects[hap_handler.HAP_TLV_TAGS.SEQUENCE_NUM] == hap_handler.HAP_TLV_STATES.M2)
async def test_homekit_start_in_accessory_mode(hass, hk_driver, device_reg): """Test HomeKit start method in accessory mode.""" entry = await async_init_integration(hass) pin = b"123-45-678" homekit = _mock_homekit(hass, entry, HOMEKIT_MODE_ACCESSORY) homekit.bridge = Mock() homekit.bridge.accessories = [] homekit.driver = hk_driver # pylint: disable=protected-access homekit._filter = Mock(return_value=True) homekit.driver.accessory = Accessory(hk_driver, "any") hass.states.async_set("light.demo", "on") with patch(f"{PATH_HOMEKIT}.HomeKit.add_bridge_accessory") as mock_add_acc, patch( "pyhap.accessory_driver.AccessoryDriver.add_accessory" ), patch(f"{PATH_HOMEKIT}.show_setup_message") as mock_setup_msg, patch( "pyhap.accessory_driver.AccessoryDriver.async_start" ) as hk_driver_start: await homekit.async_start() await hass.async_block_till_done() mock_add_acc.assert_not_called() mock_setup_msg.assert_called_with( hass, entry.entry_id, "Mock Title (any)", pin, ANY ) assert hk_driver_start.called assert homekit.status == STATUS_RUNNING
async def test_pairing_changed(driver): """Test we update mdns when the pairing changes.""" loop = MagicMock() run_in_executor_called = False async def _run_in_executor(*_): nonlocal run_in_executor_called run_in_executor_called = True loop.run_in_executor = _run_in_executor transport = MagicMock() connections = {} acc = Accessory(driver, "TestAcc") driver.add_accessory(acc) hap_proto = hap_protocol.HAPServerProtocol(loop, connections, driver) hap_proto.connection_made(transport) def _make_response(*_): response = HAPResponse() response.pairing_changed = True return response with patch.object(hap_proto.transport, "write"), patch.object( hap_proto.handler, "dispatch", _make_response ): hap_proto.data_received( b"POST /pair-setup HTTP/1.1\r\nHost: Bridge\\032C77C47._hap._tcp.local\r\nContent-Length: 6\r\nContent-Type: application/pairing+tlv8\r\n\r\n\x00\x01\x00\x06\x01\x01" # pylint: disable=line-too-long ) await asyncio.sleep(0) assert run_in_executor_called is True hap_proto.close()
def test_upgrade_to_encrypted(driver): """Test we switch to encrypted wen we get a shared_key.""" loop = MagicMock() transport = MagicMock() connections = {} acc = Accessory(driver, "TestAcc") driver.add_accessory(acc) hap_proto = hap_protocol.HAPServerProtocol(loop, connections, driver) hap_proto.connection_made(transport) assert hap_proto.hap_crypto is None def _make_response(*_): response = HAPResponse() response.shared_key = b"newkey" return response with patch.object(hap_proto.transport, "write"), patch.object( hap_proto.handler, "dispatch", _make_response ): hap_proto.data_received( b"POST /pair-setup HTTP/1.1\r\nHost: Bridge\\032C77C47._hap._tcp.local\r\nContent-Length: 6\r\nContent-Type: application/pairing+tlv8\r\n\r\n\x00\x01\x00\x06\x01\x01" # pylint: disable=line-too-long ) assert hap_proto.hap_crypto is not None hap_proto.close()
async def test_homekit_start_in_accessory_mode(hass, hk_driver, mock_zeroconf, device_reg): """Test HomeKit start method in accessory mode.""" entry = await async_init_integration(hass) homekit = _mock_homekit(hass, entry, HOMEKIT_MODE_ACCESSORY) homekit.bridge = Mock() homekit.bridge.accessories = [] homekit.driver = hk_driver homekit.driver.accessory = Accessory(hk_driver, "any") hass.states.async_set("light.demo", "on") with patch( f"{PATH_HOMEKIT}.HomeKit.add_bridge_accessory" ) as mock_add_acc, patch( f"{PATH_HOMEKIT}.show_setup_message") as mock_setup_msg, patch( "pyhap.accessory_driver.AccessoryDriver.async_start" ) as hk_driver_start: await homekit.async_start() await hass.async_block_till_done() mock_add_acc.assert_not_called() mock_setup_msg.assert_called_with(hass, entry.entry_id, "Mock Title (demo)", ANY, ANY) assert hk_driver_start.called assert homekit.status == STATUS_RUNNING
async def test_homekit_too_many_accessories(hass, hk_driver, caplog, mock_zeroconf): """Test adding too many accessories to HomeKit.""" entry = await async_init_integration(hass) entity_filter = generate_filter(["cover", "light"], ["demo.test"], [], []) homekit = _mock_homekit(hass, entry, HOMEKIT_MODE_BRIDGE, entity_filter) def _mock_bridge(*_): mock_bridge = HomeBridge(hass, hk_driver, "mock_bridge") # The bridge itself counts as an accessory mock_bridge.accessories = range(MAX_DEVICES) return mock_bridge homekit.driver = hk_driver homekit.driver.accessory = Accessory(hk_driver, "any") hass.states.async_set("light.demo", "on") hass.states.async_set("light.demo2", "on") hass.states.async_set("light.demo3", "on") with patch("pyhap.accessory_driver.AccessoryDriver.async_start"), patch( f"{PATH_HOMEKIT}.show_setup_message"), patch( f"{PATH_HOMEKIT}.HomeBridge", _mock_bridge): await homekit.async_start() await hass.async_block_till_done() assert "would exceed" in caplog.text
def test_mdns_service_info(driver): """Test accessory mdns advert.""" acc = Accessory(driver, "[@@@Test@@@] Accessory") driver.add_accessory(acc) addr = "172.0.0.1" mac = "00:00:00:00:00:00" pin = b"123-45-678" port = 11111 state = State(address=addr, mac=mac, pincode=pin, port=port) state.setup_id = "abc" mdns_info = AccessoryMDNSServiceInfo(acc, state) assert mdns_info.type == "_hap._tcp.local." assert mdns_info.name == "Test Accessory 000000._hap._tcp.local." assert mdns_info.port == port assert mdns_info.addresses == [b"\xac\x00\x00\x01"] assert mdns_info.properties == { "md": "Test Accessory", "pv": "1.0", "id": "00:00:00:00:00:00", "c#": "2", "s#": "1", "ff": "0", "ci": "1", "sf": "1", "sh": "+KjpzQ==", }
async def test_start_service_and_update_config(): """Test starting service and updating the config.""" with patch("pyhap.accessory_driver.HAPServer.async_stop", new_callable=AsyncMock), patch( "pyhap.accessory_driver.HAPServer.async_start", new_callable=AsyncMock ), patch("pyhap.accessory_driver.Zeroconf"), patch( "pyhap.accessory_driver.AccessoryDriver.persist"), patch( "pyhap.accessory_driver.AccessoryDriver.load"): driver = AccessoryDriver(loop=asyncio.get_event_loop()) acc = Accessory(driver, "TestAcc") driver.add_accessory(acc) await driver.async_start() assert driver.state.config_version == 2 driver.config_changed() assert driver.state.config_version == 3 driver.state.config_version = 65535 driver.config_changed() assert driver.state.config_version == 1 for _ in range(3): await asyncio.sleep(0) await driver.async_stop() await asyncio.sleep(0) assert not driver.loop.is_closed() assert driver.aio_stop_event.is_set()
def test_pair_verify_one_not_paired(driver): """Verify an unencrypted pair verify one.""" driver.add_accessory(Accessory(driver, "TestAcc")) handler = hap_handler.HAPServerHandler(driver, "peername") handler.is_encrypted = False response = hap_handler.HAPResponse() handler.response = response handler.request_body = tlv.encode( hap_handler.HAP_TLV_TAGS.SEQUENCE_NUM, hap_handler.HAP_TLV_STATES.M1, hap_handler.HAP_TLV_TAGS.PUBLIC_KEY, PUBLIC_KEY, ) handler.handle_pair_verify() tlv_objects = tlv.decode(response.body) assert tlv_objects == { hap_handler.HAP_TLV_TAGS.SEQUENCE_NUM: hap_handler.HAP_TLV_STATES.M2, hap_handler.HAP_TLV_TAGS.ERROR_CODE: hap_handler.HAP_TLV_ERRORS.AUTHENTICATION, }