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,
}
