async def test_respond_to_read(self):
"""Test respond_to_read function."""
xknx = XKNX()
responding = NumericValue(
xknx,
"TestSensor1",
group_address="1/1/1",
respond_to_read=True,
value_type="volume_liquid_litre",
)
non_responding = NumericValue(
xknx,
"TestSensor2",
group_address="1/1/1",
respond_to_read=False,
value_type="volume_liquid_litre",
)
responding_multiple = NumericValue(
xknx,
"TestSensor3",
group_address=["1/1/1", "3/3/3"],
group_address_state="2/2/2",
respond_to_read=True,
value_type="volume_liquid_litre",
)
# set initial payload of NumericValue
responding.sensor_value.value = 256
non_responding.sensor_value.value = 256
responding_multiple.sensor_value.value = 256
read_telegram = Telegram(destination_address=GroupAddress("1/1/1"),
payload=GroupValueRead())
# verify no response when respond is False
await non_responding.process(read_telegram)
assert xknx.telegrams.qsize() == 0
# verify response when respond is True
await responding.process(read_telegram)
assert xknx.telegrams.qsize() == 1
response = xknx.telegrams.get_nowait()
assert response == Telegram(
destination_address=GroupAddress("1/1/1"),
payload=GroupValueResponse(DPTArray((0x00, 0x00, 0x01, 0x00))),
)
# verify no response when GroupValueRead request is not for group_address
await responding_multiple.process(read_telegram)
assert xknx.telegrams.qsize() == 1
response = xknx.telegrams.get_nowait()
assert response == Telegram(
destination_address=GroupAddress("1/1/1"),
payload=GroupValueResponse(DPTArray((0x00, 0x00, 0x01, 0x00))),
)
await responding_multiple.process(
Telegram(destination_address=GroupAddress("2/2/2"),
payload=GroupValueRead()))
await responding_multiple.process(
Telegram(destination_address=GroupAddress("3/3/3"),
payload=GroupValueRead()))
assert xknx.telegrams.qsize() == 0
async def test_respond_to_read(self):
"""Test respond_to_read function."""
xknx = XKNX()
responding = Switch(
xknx,
"TestSensor1",
group_address="1/1/1",
respond_to_read=True,
)
non_responding = Switch(
xknx,
"TestSensor2",
group_address="1/1/1",
respond_to_read=False,
)
responding_multiple = Switch(
xknx,
"TestSensor3",
group_address=["1/1/1", "3/3/3"],
group_address_state="2/2/2",
respond_to_read=True,
)
# set initial payload of Switch
responding.switch.value = True
non_responding.switch.value = True
responding_multiple.switch.value = True
read_telegram = Telegram(destination_address=GroupAddress("1/1/1"),
payload=GroupValueRead())
# verify no response when respond is False
await non_responding.process(read_telegram)
assert xknx.telegrams.qsize() == 0
# verify response when respond is True
await responding.process(read_telegram)
assert xknx.telegrams.qsize() == 1
response = xknx.telegrams.get_nowait()
assert response == Telegram(
destination_address=GroupAddress("1/1/1"),
payload=GroupValueResponse(DPTBinary(True)),
)
# verify no response when GroupValueRead request is not for group_address
await responding_multiple.process(read_telegram)
assert xknx.telegrams.qsize() == 1
response = xknx.telegrams.get_nowait()
assert response == Telegram(
destination_address=GroupAddress("1/1/1"),
payload=GroupValueResponse(DPTBinary(True)),
)
await responding_multiple.process(
Telegram(destination_address=GroupAddress("2/2/2"),
payload=GroupValueRead()))
await responding_multiple.process(
Telegram(destination_address=GroupAddress("3/3/3"),
payload=GroupValueRead()))
assert xknx.telegrams.qsize() == 0
async def test_process_state(self):
"""Test process / reading telegrams from telegram queue. Test if device was updated."""
xknx = XKNX()
callback_mock = AsyncMock()
switch1 = Switch(
xknx,
"TestOutlet",
group_address="1/2/3",
group_address_state="1/2/4",
device_updated_cb=callback_mock,
)
switch2 = Switch(
xknx,
"TestOutlet",
group_address="1/2/3",
group_address_state="1/2/4",
device_updated_cb=callback_mock,
)
assert switch1.state is None
assert switch2.state is None
callback_mock.assert_not_called()
telegram_on = Telegram(
destination_address=GroupAddress("1/2/4"),
payload=GroupValueResponse(DPTBinary(1)),
)
telegram_off = Telegram(
destination_address=GroupAddress("1/2/4"),
payload=GroupValueResponse(DPTBinary(0)),
)
await switch1.process(telegram_on)
assert switch1.state is True
callback_mock.assert_called_once()
callback_mock.reset_mock()
await switch1.process(telegram_off)
assert switch1.state is False
callback_mock.assert_called_once()
callback_mock.reset_mock()
# test setting switch2 to False with first telegram
await switch2.process(telegram_off)
assert switch2.state is False
callback_mock.assert_called_once()
callback_mock.reset_mock()
await switch2.process(telegram_on)
assert switch2.state is True
callback_mock.assert_called_once()
callback_mock.reset_mock()
async def test_always_callback_sensor(self):
"""Test always callback sensor."""
xknx = XKNX()
sensor = Sensor(
xknx,
"TestSensor",
group_address_state="1/2/3",
always_callback=False,
value_type="volume_liquid_litre",
)
after_update_callback = AsyncMock()
sensor.register_device_updated_cb(after_update_callback)
payload = DPTArray((0x00, 0x00, 0x01, 0x00))
# set initial payload of sensor
sensor.sensor_value.value = 256
telegram = Telegram(destination_address=GroupAddress("1/2/3"),
payload=GroupValueWrite(payload))
response_telegram = Telegram(
destination_address=GroupAddress("1/2/3"),
payload=GroupValueResponse(payload),
)
# verify not called when always_callback is False
await sensor.process(telegram)
after_update_callback.assert_not_called()
after_update_callback.reset_mock()
sensor.always_callback = True
# verify called when always_callback is True
await sensor.process(telegram)
after_update_callback.assert_called_once()
after_update_callback.reset_mock()
# verify not called when processing read responses
await sensor.process(response_telegram)
after_update_callback.assert_not_called()
async def test_process(self):
"""Test if telegram is handled by the correct process_* method."""
xknx = XKNX()
device = Device(xknx, "TestDevice")
with patch("xknx.devices.Device.process_group_read",
new_callable=AsyncMock) as mock_group_read:
telegram = Telegram(destination_address=GroupAddress("1/2/1"),
payload=GroupValueRead())
await device.process(telegram)
mock_group_read.assert_called_with(telegram)
with patch("xknx.devices.Device.process_group_write",
new_callable=AsyncMock) as mock_group_write:
telegram = Telegram(
destination_address=GroupAddress("1/2/1"),
payload=GroupValueWrite(DPTArray((0x01, 0x02))),
)
await device.process(telegram)
mock_group_write.assert_called_with(telegram)
with patch("xknx.devices.Device.process_group_response",
new_callable=AsyncMock) as mock_group_response:
telegram = Telegram(
destination_address=GroupAddress("1/2/1"),
payload=GroupValueResponse(DPTArray((0x01, 0x02))),
)
await device.process(telegram)
mock_group_response.assert_called_with(telegram)
async def service_send_to_knx_bus(self, call: ServiceCall) -> None:
"""Service for sending an arbitrary KNX message to the KNX bus."""
attr_address = call.data[KNX_ADDRESS]
attr_payload = call.data[SERVICE_KNX_ATTR_PAYLOAD]
attr_type = call.data.get(SERVICE_KNX_ATTR_TYPE)
attr_response = call.data[SERVICE_KNX_ATTR_RESPONSE]
payload: DPTBinary | DPTArray
if attr_type is not None:
transcoder = DPTBase.parse_transcoder(attr_type)
if transcoder is None:
raise ValueError(
f"Invalid type for knx.send service: {attr_type}")
payload = DPTArray(transcoder.to_knx(attr_payload))
elif isinstance(attr_payload, int):
payload = DPTBinary(attr_payload)
else:
payload = DPTArray(attr_payload)
for address in attr_address:
telegram = Telegram(
destination_address=parse_device_group_address(address),
payload=GroupValueResponse(payload)
if attr_response else GroupValueWrite(payload),
)
await self.xknx.telegrams.put(telegram)
def test_EndTOEnd_group_response(self):
"""Test parsing and streaming CEMIFrame KNX/IP packet, group response."""
# Incoming state
raw = bytes.fromhex("0610053000112900BCD013010188010041")
xknx = XKNX()
knxipframe = KNXIPFrame(xknx)
knxipframe.from_knx(raw)
telegram = knxipframe.body.cemi.telegram
self.assertEqual(
telegram,
Telegram(
destination_address=GroupAddress("392"),
payload=GroupValueResponse(DPTBinary(1)),
source_address=IndividualAddress("1.3.1"),
),
)
cemi = CEMIFrame(xknx, src_addr=IndividualAddress("1.3.1"))
cemi.telegram = telegram
cemi.set_hops(5)
routing_indication = RoutingIndication(xknx, cemi=cemi)
knxipframe2 = KNXIPFrame.init_from_body(routing_indication)
self.assertEqual(knxipframe2.header.to_knx(), list(raw[0:6]))
self.assertEqual(knxipframe2.body.to_knx(), list(raw[6:]))
self.assertEqual(knxipframe2.to_knx(), list(raw))
def test_process_read(self):
"""Test test process a read telegram from KNX bus."""
xknx = XKNX()
datetime = DateTime(xknx,
"TestDateTime",
group_address="1/2/3",
broadcast_type="TIME")
telegram_read = Telegram(destination_address=GroupAddress("1/2/3"),
payload=GroupValueRead())
with patch("time.localtime") as mock_time:
mock_time.return_value = time.struct_time(
[2017, 1, 7, 9, 13, 14, 6, 0, 0])
self.loop.run_until_complete(datetime.process(telegram_read))
# initial Telegram from broadcasting on init
self.assertEqual(xknx.telegrams.qsize(), 2)
_throwaway_initial = xknx.telegrams.get_nowait()
telegram = xknx.telegrams.get_nowait()
self.assertEqual(
telegram,
Telegram(
destination_address=GroupAddress("1/2/3"),
payload=GroupValueResponse(DPTArray((0xE9, 0xD, 0xE))),
),
)
async def test_process_group_value_response(self):
"""Test precess of GroupValueResponse telegrams."""
xknx = XKNX()
switch = BinarySensor(
xknx,
"TestInput",
group_address_state="1/2/3",
ignore_internal_state=True,
)
async_after_update_callback = AsyncMock()
switch.register_device_updated_cb(async_after_update_callback)
write_telegram = Telegram(
destination_address=GroupAddress("1/2/3"),
payload=GroupValueWrite(DPTBinary(1)),
)
response_telegram = Telegram(
destination_address=GroupAddress("1/2/3"),
payload=GroupValueResponse(DPTBinary(1), ),
)
assert switch.state is None
# initial GroupValueResponse changes state and runs callback
await switch.process(response_telegram)
assert switch.state
async_after_update_callback.assert_called_once_with(switch)
# GroupValueWrite with same payload runs callback because of `ignore_internal_state`
async_after_update_callback.reset_mock()
await switch.process(write_telegram)
assert switch.state
async_after_update_callback.assert_called_once_with(switch)
# GroupValueResponse should not run callback when state has not changed
async_after_update_callback.reset_mock()
await switch.process(response_telegram)
async_after_update_callback.assert_not_called()
def test_value_reader_telegram_received(self):
"""Test value reader: telegram_received."""
xknx = XKNX()
test_group_address = GroupAddress("0/0/0")
expected_telegram_1 = Telegram(
destination_address=test_group_address,
direction=TelegramDirection.INCOMING,
payload=GroupValueResponse(DPTBinary(1)),
)
expected_telegram_2 = Telegram(
destination_address=test_group_address,
direction=TelegramDirection.INCOMING,
payload=GroupValueWrite(DPTBinary(1)),
)
telegram_wrong_address = Telegram(
destination_address=GroupAddress("0/0/1"),
direction=TelegramDirection.INCOMING,
payload=GroupValueResponse(DPTBinary(1)),
)
telegram_wrong_type = Telegram(
destination_address=test_group_address,
direction=TelegramDirection.INCOMING,
payload=GroupValueRead(),
)
value_reader = ValueReader(xknx, test_group_address)
def async_telegram_received(test_telegram):
return self.loop.run_until_complete(
value_reader.telegram_received(test_telegram)
)
async_telegram_received(telegram_wrong_address)
self.assertIsNone(value_reader.received_telegram)
self.assertFalse(value_reader.success)
async_telegram_received(telegram_wrong_type)
self.assertIsNone(value_reader.received_telegram)
self.assertFalse(value_reader.success)
async_telegram_received(expected_telegram_1)
self.assertEqual(value_reader.received_telegram, expected_telegram_1)
self.assertTrue(value_reader.success)
async_telegram_received(expected_telegram_2)
self.assertEqual(value_reader.received_telegram, expected_telegram_2)
self.assertTrue(value_reader.success)
async def test_array_sensor_loop(self, value_type, test_payload, test_value):
"""Test sensor and expose_sensor with different values."""
xknx = XKNX()
xknx.knxip_interface = AsyncMock()
xknx.rate_limit = False
await xknx.telegram_queue.start()
expose = ExposeSensor(
xknx,
"TestExpose",
group_address="1/1/1",
value_type=value_type,
)
assert expose.resolve_state() is None
# set a value from expose - HA sends strings for new values
stringified_value = str(test_value)
await expose.set(stringified_value)
outgoing_telegram = Telegram(
destination_address=GroupAddress("1/1/1"),
direction=TelegramDirection.OUTGOING,
payload=GroupValueWrite(test_payload),
)
await xknx.telegrams.join()
xknx.knxip_interface.send_telegram.assert_called_with(outgoing_telegram)
assert expose.resolve_state() == test_value
# init sensor after expose is set - with same group address
sensor = Sensor(
xknx,
"TestSensor",
group_address_state="1/1/1",
value_type=value_type,
)
assert sensor.resolve_state() is None
# read sensor state (from expose as it has the same GA)
# wait_for_result so we don't have to await self.xknx.telegrams.join()
await sensor.sync(wait_for_result=True)
read_telegram = Telegram(
destination_address=GroupAddress("1/1/1"),
direction=TelegramDirection.OUTGOING,
payload=GroupValueRead(),
)
response_telegram = Telegram(
destination_address=GroupAddress("1/1/1"),
direction=TelegramDirection.OUTGOING,
payload=GroupValueResponse(test_payload),
)
xknx.knxip_interface.send_telegram.assert_has_calls(
[
call(read_telegram),
call(response_telegram),
]
)
# test if Sensor has successfully read from ExposeSensor
assert sensor.resolve_state() == test_value
assert expose.resolve_state() == sensor.resolve_state()
await xknx.telegram_queue.stop()
async def test_value_reader_telegram_received(self):
"""Test value reader: telegram_received."""
xknx = XKNX()
test_group_address = GroupAddress("0/0/0")
expected_telegram_1 = Telegram(
destination_address=test_group_address,
direction=TelegramDirection.INCOMING,
payload=GroupValueResponse(DPTBinary(1)),
)
expected_telegram_2 = Telegram(
destination_address=test_group_address,
direction=TelegramDirection.INCOMING,
payload=GroupValueWrite(DPTBinary(1)),
)
telegram_wrong_address = Telegram(
destination_address=GroupAddress("0/0/1"),
direction=TelegramDirection.INCOMING,
payload=GroupValueResponse(DPTBinary(1)),
)
telegram_wrong_type = Telegram(
destination_address=test_group_address,
direction=TelegramDirection.INCOMING,
payload=GroupValueRead(),
)
value_reader = ValueReader(xknx, test_group_address)
await value_reader.telegram_received(telegram_wrong_address)
assert value_reader.received_telegram is None
assert not value_reader.response_received_event.is_set()
await value_reader.telegram_received(telegram_wrong_type)
assert value_reader.received_telegram is None
assert not value_reader.response_received_event.is_set()
await value_reader.telegram_received(expected_telegram_1)
assert value_reader.received_telegram == expected_telegram_1
assert value_reader.response_received_event.is_set()
await value_reader.telegram_received(expected_telegram_2)
assert value_reader.received_telegram == expected_telegram_2
assert value_reader.response_received_event.is_set()
async def _send(self,
payload: "DPTPayload",
response: bool = False) -> None:
"""Send payload as telegram to KNX bus."""
if self.group_address is not None:
telegram = Telegram(
destination_address=self.group_address,
payload=(GroupValueResponse(payload)
if response else GroupValueWrite(payload)),
)
await self.xknx.telegrams.put(telegram)
def test_process_temperature(self):
"""Test reading temperature expose sensor from bus."""
xknx = XKNX()
expose_sensor = ExposeSensor(
xknx, "TestSensor", value_type="temperature", group_address="1/2/3"
)
expose_sensor.sensor_value.payload = DPTArray((0x0C, 0x1A))
telegram = Telegram(GroupAddress("1/2/3"), payload=GroupValueRead())
self.loop.run_until_complete(expose_sensor.process(telegram))
self.assertEqual(xknx.telegrams.qsize(), 1)
telegram = xknx.telegrams.get_nowait()
self.assertEqual(
telegram,
Telegram(
destination_address=GroupAddress("1/2/3"),
payload=GroupValueResponse(DPTArray((0x0C, 0x1A))),
),
)
async def test_process_read(self):
"""Test test process a read telegram from KNX bus."""
xknx = XKNX()
self.datetime = DateTime(xknx,
"TestDateTime",
group_address="1/2/3",
broadcast_type="TIME")
telegram_read = Telegram(destination_address=GroupAddress("1/2/3"),
payload=GroupValueRead())
with patch("time.localtime") as mock_time:
mock_time.return_value = time.struct_time(
[2017, 1, 7, 9, 13, 14, 6, 0, 0])
await self.datetime.process(telegram_read)
telegram = xknx.telegrams.get_nowait()
assert telegram == Telegram(
destination_address=GroupAddress("1/2/3"),
payload=GroupValueResponse(DPTArray((0xE9, 0xD, 0xE))),
)
def test_process_reset_after_cancel_existing(self):
"""Test process reset_after cancels existing reset tasks."""
xknx = XKNX()
reset_after_sec = 0.01
switch = Switch(
xknx, "TestInput", group_address="1/2/3", reset_after=reset_after_sec
)
telegram_on = Telegram(
destination_address=GroupAddress("1/2/3"),
payload=GroupValueResponse(DPTBinary(1)),
)
self.loop.run_until_complete(switch.process(telegram_on))
self.assertTrue(switch.state)
self.assertEqual(xknx.telegrams.qsize(), 0)
self.loop.run_until_complete(asyncio.sleep(reset_after_sec / 2))
# half way through the reset timer
self.loop.run_until_complete(switch.process(telegram_on))
self.assertTrue(switch.state)
self.loop.run_until_complete(asyncio.sleep(reset_after_sec / 2))
self.assertEqual(xknx.telegrams.qsize(), 0)
async def test_process_temperature(self):
"""Test reading temperature expose sensor from bus."""
xknx = XKNX()
expose_sensor = ExposeSensor(xknx,
"TestSensor",
value_type="temperature",
group_address="1/2/3")
await expose_sensor.process(
Telegram(
destination_address=GroupAddress("1/2/3"),
payload=GroupValueWrite(DPTArray((0x0C, 0x1A))),
))
telegram = Telegram(GroupAddress("1/2/3"), payload=GroupValueRead())
await expose_sensor.process(telegram)
assert xknx.telegrams.qsize() == 1
telegram = xknx.telegrams.get_nowait()
assert telegram == Telegram(
destination_address=GroupAddress("1/2/3"),
payload=GroupValueResponse(DPTArray((0x0C, 0x1A))),
)
async def test_process_binary(self):
"""Test reading binary expose sensor from bus."""
xknx = XKNX()
expose_sensor = ExposeSensor(xknx,
"TestSensor",
value_type="binary",
group_address="1/2/3")
await expose_sensor.process(
Telegram(
destination_address=GroupAddress("1/2/3"),
payload=GroupValueWrite(DPTBinary(True)),
))
telegram = Telegram(GroupAddress("1/2/3"), payload=GroupValueRead())
await expose_sensor.process(telegram)
assert xknx.telegrams.qsize() == 1
telegram = xknx.telegrams.get_nowait()
assert telegram == Telegram(
destination_address=GroupAddress("1/2/3"),
payload=GroupValueResponse(DPTBinary(True)),
)
async def test_process_reset_after_cancel_existing(self, time_travel):
"""Test process reset_after cancels existing reset tasks."""
xknx = XKNX()
reset_after_sec = 0.01
switch = Switch(xknx,
"TestInput",
group_address="1/2/3",
reset_after=reset_after_sec)
telegram_on = Telegram(
destination_address=GroupAddress("1/2/3"),
payload=GroupValueResponse(DPTBinary(1)),
)
await switch.process(telegram_on)
assert switch.state
assert xknx.telegrams.qsize() == 0
await time_travel(reset_after_sec / 2)
# half way through the reset timer
await switch.process(telegram_on)
assert switch.state
await time_travel(reset_after_sec / 2)
assert xknx.telegrams.qsize() == 0
def test_end_to_end_group_response(self):
"""Test parsing and streaming CEMIFrame KNX/IP packet, group response."""
# Incoming state
raw = bytes.fromhex(
"06 10 05 30 00 11 29 00 bc d0 13 01 01 88 01 00 41")
knxipframe = KNXIPFrame()
knxipframe.from_knx(raw)
telegram = knxipframe.body.cemi.telegram
assert telegram == Telegram(
destination_address=GroupAddress("392"),
payload=GroupValueResponse(DPTBinary(1)),
source_address=IndividualAddress("1.3.1"),
)
cemi = CEMIFrame(src_addr=IndividualAddress("1.3.1"))
cemi.telegram = telegram
cemi.set_hops(5)
routing_indication = RoutingIndication(cemi=cemi)
knxipframe2 = KNXIPFrame.init_from_body(routing_indication)
assert knxipframe2.header.to_knx() == raw[0:6]
assert knxipframe2.body.to_knx() == raw[6:]
assert knxipframe2.to_knx() == raw
def test_value_reader_read_success(self):
"""Test value reader: successfull read."""
xknx = XKNX()
test_group_address = GroupAddress("0/0/0")
response_telegram = Telegram(
destination_address=test_group_address,
direction=TelegramDirection.INCOMING,
payload=GroupValueResponse(DPTBinary(1)),
)
value_reader = ValueReader(xknx, test_group_address)
# receive the response
self.loop.run_until_complete(value_reader.telegram_received(response_telegram))
# and yield the result
successfull_read = self.loop.run_until_complete(value_reader.read())
# GroupValueRead telegram is still in the queue because we are not actually processing it
self.assertEqual(xknx.telegrams.qsize(), 1)
# Callback was removed again
self.assertEqual(xknx.telegram_queue.telegram_received_cbs, [])
# Telegram was received
self.assertEqual(value_reader.received_telegram, response_telegram)
# Successfull read() returns the telegram
self.assertEqual(successfull_read, response_telegram)
async def test_value_reader_read_success(self):
"""Test value reader: successfull read."""
xknx = XKNX()
test_group_address = GroupAddress("0/0/0")
response_telegram = Telegram(
destination_address=test_group_address,
direction=TelegramDirection.INCOMING,
payload=GroupValueResponse(DPTBinary(1)),
)
value_reader = ValueReader(xknx, test_group_address)
# receive the response
await value_reader.telegram_received(response_telegram)
# and yield the result
successfull_read = await value_reader.read()
# GroupValueRead telegram is still in the queue because we are not actually processing it
assert xknx.telegrams.qsize() == 1
# Callback was removed again
assert not xknx.telegram_queue.telegram_received_cbs
# Telegram was received
assert value_reader.received_telegram == response_telegram
# Successfull read() returns the telegram
assert successfull_read == response_telegram
def test_process(self):
"""Test if telegram is handled by the correct process_* method."""
xknx = XKNX()
device = Device(xknx, "TestDevice")
with patch("xknx.devices.Device.process_group_read") as mock_group_read:
fut = asyncio.Future()
fut.set_result(None)
mock_group_read.return_value = fut
telegram = Telegram(
destination_address=GroupAddress("1/2/1"), payload=GroupValueRead()
)
self.loop.run_until_complete(device.process(telegram))
mock_group_read.assert_called_with(telegram)
with patch("xknx.devices.Device.process_group_write") as mock_group_write:
fut = asyncio.Future()
fut.set_result(None)
mock_group_write.return_value = fut
telegram = Telegram(
destination_address=GroupAddress("1/2/1"),
payload=GroupValueWrite(DPTArray((0x01, 0x02))),
)
self.loop.run_until_complete(device.process(telegram))
mock_group_write.assert_called_with(telegram)
with patch("xknx.devices.Device.process_group_response") as mock_group_response:
fut = asyncio.Future()
fut.set_result(None)
mock_group_response.return_value = fut
telegram = Telegram(
destination_address=GroupAddress("1/2/1"),
payload=GroupValueResponse(DPTArray((0x01, 0x02))),
)
self.loop.run_until_complete(device.process(telegram))
mock_group_response.assert_called_with(telegram)
async def test_binary_sensor_loop(self, value_type, test_payload, test_value):
"""Test binary_sensor and expose_sensor with binary values."""
xknx = XKNX()
xknx.knxip_interface = AsyncMock()
xknx.rate_limit = False
telegram_callback = AsyncMock()
xknx.telegram_queue.register_telegram_received_cb(
telegram_callback,
address_filters=[AddressFilter("i-test")],
match_for_outgoing=True,
)
await xknx.telegram_queue.start()
expose = ExposeSensor(
xknx,
"TestExpose",
group_address="i-test",
value_type=value_type,
)
assert expose.resolve_state() is None
await expose.set(test_value)
await xknx.telegrams.join()
outgoing_telegram = Telegram(
destination_address=InternalGroupAddress("i-test"),
direction=TelegramDirection.OUTGOING,
payload=GroupValueWrite(test_payload),
)
# InternalGroupAddress isn't passed to knxip_interface
xknx.knxip_interface.send_telegram.assert_not_called()
telegram_callback.assert_called_with(outgoing_telegram)
assert expose.resolve_state() == test_value
bin_sensor = BinarySensor(xknx, "TestSensor", group_address_state="i-test")
assert bin_sensor.state is None
# read sensor state (from expose as it has the same GA)
# wait_for_result so we don't have to await self.xknx.telegrams.join()
await bin_sensor.sync(wait_for_result=True)
read_telegram = Telegram(
destination_address=InternalGroupAddress("i-test"),
direction=TelegramDirection.OUTGOING,
payload=GroupValueRead(),
)
response_telegram = Telegram(
destination_address=InternalGroupAddress("i-test"),
direction=TelegramDirection.OUTGOING,
payload=GroupValueResponse(test_payload),
)
xknx.knxip_interface.send_telegram.assert_not_called()
telegram_callback.assert_has_calls(
[
call(read_telegram),
call(response_telegram),
]
)
# test if Sensor has successfully read from ExposeSensor
assert bin_sensor.state == test_value
assert expose.resolve_state() == bin_sensor.state
await xknx.telegram_queue.stop()
async def receive_response(self, group_address: str,
payload: int | tuple[int, ...]) -> None:
"""Inject incoming GroupValueResponse telegram."""
payload_value = self._payload_value(payload)
await self._receive_telegram(group_address,
GroupValueResponse(payload_value))
