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()
def test_str_temperature(self):
"""Test resolve state with temperature sensor."""
xknx = XKNX()
expose_sensor = ExposeSensor(
xknx, "TestSensor", group_address="1/2/3", value_type="temperature"
)
expose_sensor.sensor_value.payload = DPTArray((0x0C, 0x1A))
self.assertEqual(expose_sensor.resolve_state(), 21.0)
self.assertEqual(expose_sensor.unit_of_measurement(), "°C")
def test_str_percent(self):
"""Test resolve state with percent sensor."""
xknx = XKNX()
expose_sensor = ExposeSensor(
xknx, "TestSensor", group_address="1/2/3", value_type="percent"
)
expose_sensor.sensor_value.payload = DPTArray((0x40,))
self.assertEqual(expose_sensor.resolve_state(), 25)
self.assertEqual(expose_sensor.unit_of_measurement(), "%")
def test_str_binary(self):
"""Test resolve state with binary sensor."""
xknx = XKNX()
expose_sensor = ExposeSensor(
xknx, "TestSensor", group_address="1/2/3", value_type="binary"
)
expose_sensor.sensor_value.payload = DPTBinary(1)
self.assertEqual(expose_sensor.resolve_state(), True)
self.assertEqual(expose_sensor.unit_of_measurement(), None)
def test_str_temperature(self):
"""Test resolve state with temperature sensor."""
xknx = XKNX(loop=self.loop)
expose_sensor = ExposeSensor(
xknx,
'TestSensor',
group_address='1/2/3',
value_type="temperature")
expose_sensor.sensor_value.payload = DPTArray((0x0c, 0x1a))
self.assertEqual(expose_sensor.resolve_state(), 21.0)
self.assertEqual(expose_sensor.unit_of_measurement(), "°C")
def test_str_percent(self):
"""Test resolve state with percent sensor."""
xknx = XKNX(loop=self.loop)
expose_sensor = ExposeSensor(
xknx,
'TestSensor',
group_address='1/2/3',
value_type="percent")
expose_sensor.sensor_value.payload = DPTArray((0x40,))
self.assertEqual(expose_sensor.resolve_state(), 25)
self.assertEqual(expose_sensor.unit_of_measurement(), "%")
def test_str_binary(self):
"""Test resolve state with binary sensor."""
xknx = XKNX(loop=self.loop)
expose_sensor = ExposeSensor(
xknx,
'TestSensor',
group_address='1/2/3',
value_type="binary")
expose_sensor.sensor_value.payload = DPTBinary(1)
self.assertEqual(expose_sensor.resolve_state(), True)
self.assertEqual(expose_sensor.unit_of_measurement(), None)
async def test_str_binary(self):
"""Test resolve state with binary sensor."""
xknx = XKNX()
expose_sensor = ExposeSensor(xknx,
"TestSensor",
group_address="1/2/3",
value_type="binary")
await expose_sensor.process(
Telegram(
destination_address=GroupAddress("1/2/3"),
payload=GroupValueWrite(value=DPTBinary(1)),
))
assert expose_sensor.resolve_state() is True
assert expose_sensor.unit_of_measurement() is None
async def test_str_temperature(self):
"""Test resolve state with temperature sensor."""
xknx = XKNX()
expose_sensor = ExposeSensor(xknx,
"TestSensor",
group_address="1/2/3",
value_type="temperature")
await expose_sensor.process(
Telegram(
destination_address=GroupAddress("1/2/3"),
payload=GroupValueWrite(DPTArray((0x0C, 0x1A))),
))
assert expose_sensor.resolve_state() == 21.0
assert expose_sensor.unit_of_measurement() == "°C"
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()
