async def send(self, response=False):
"""Send payload as telegram to KNX bus."""
telegram = Telegram()
telegram.group_address = self.group_address
telegram.telegramtype = TelegramType.GROUP_RESPONSE \
if response else TelegramType.GROUP_WRITE
telegram.payload = self.payload
await self.xknx.telegrams.put(telegram)
def test_process_power_status(self):
"""Test process / reading telegrams from telegram queue. Test if DPT20.105 controller mode is set correctly."""
xknx = XKNX(loop=self.loop)
climate = Climate(
xknx,
'TestClimate',
group_address_on_off='1/2/2')
telegram = Telegram(GroupAddress('1/2/2'))
telegram.payload = DPTBinary(1)
self.loop.run_until_complete(asyncio.Task(climate.process(telegram)))
self.assertEqual(climate.is_on, True)
def test_process_controller_mode(self):
"""Test process / reading telegrams from telegram queue. Test if DPT20.105 controller mode is set correctly."""
xknx = XKNX(loop=self.loop)
climate_mode = ClimateMode(
xknx,
'TestClimate',
group_address_controller_mode='1/2/5')
for _, operation_mode in DPTHVACContrMode.SUPPORTED_MODES.items():
telegram = Telegram(GroupAddress('1/2/5'))
telegram.payload = DPTArray(DPTHVACContrMode.to_knx(operation_mode))
self.loop.run_until_complete(asyncio.Task(climate_mode.process(telegram)))
self.assertEqual(climate_mode.operation_mode, operation_mode)
def test_process_temperature(self):
"""Test process / reading telegrams from telegram queue. Test if temperature is processed correctly."""
xknx = XKNX(loop=self.loop)
climate = Climate(
xknx,
'TestClimate',
group_address_temperature='1/2/3')
telegram = Telegram(GroupAddress('1/2/3'))
telegram.payload = DPTArray(DPTTemperature().to_knx(21.34))
self.loop.run_until_complete(asyncio.Task(climate.process(telegram)))
self.assertEqual(climate.temperature.value, 21.34)
def test_process(self):
"""Test process / reading telegrams from telegram queue."""
xknx = XKNX(loop=self.loop)
sensor = Sensor(
xknx,
'TestSensor',
value_type='temperature',
group_address_state='1/2/3')
telegram = Telegram(GroupAddress('1/2/3'))
telegram.payload = DPTArray((0x06, 0xa0))
self.loop.run_until_complete(asyncio.Task(sensor.process(telegram)))
self.assertEqual(sensor.sensor_value.payload, DPTArray((0x06, 0xa0)))
self.assertEqual(sensor.resolve_state(), 16.96)
def test_process_action(self):
"""Test process / reading telegrams from telegram queue. Test if action is executed."""
xknx = XKNX(loop=self.loop)
switch = Switch(xknx, 'TestOutlet', group_address='1/2/3')
xknx.devices.add(switch)
binary_sensor = BinarySensor(xknx, 'TestInput', group_address_state='1/2/3')
action_on = Action(
xknx,
hook='on',
target='TestOutlet',
method='on')
binary_sensor.actions.append(action_on)
action_off = Action(
xknx,
hook='off',
target='TestOutlet',
method='off')
binary_sensor.actions.append(action_off)
xknx.devices.add(binary_sensor)
self.assertEqual(
xknx.devices['TestInput'].state,
BinarySensorState.OFF)
self.assertEqual(
xknx.devices['TestOutlet'].state,
False)
telegram_on = Telegram()
telegram_on.payload = DPTBinary(1)
self.loop.run_until_complete(asyncio.Task(binary_sensor.process(telegram_on)))
self.assertEqual(
xknx.devices['TestInput'].state,
BinarySensorState.ON)
self.assertEqual(
xknx.devices['TestOutlet'].state,
True)
telegram_off = Telegram()
telegram_off.payload = DPTBinary(0)
self.loop.run_until_complete(asyncio.Task(binary_sensor.process(telegram_off)))
self.assertEqual(
xknx.devices['TestInput'].state,
BinarySensorState.OFF)
self.assertEqual(
xknx.devices['TestOutlet'].state,
False)
def test_process(self):
"""Test process / reading telegrams from telegram queue."""
xknx = XKNX(loop=self.loop)
binaryinput = BinarySensor(xknx, 'TestInput', '1/2/3')
self.assertEqual(binaryinput.state, BinarySensorState.OFF)
telegram_on = Telegram()
telegram_on.payload = DPTBinary(1)
self.loop.run_until_complete(asyncio.Task(binaryinput.process(telegram_on)))
self.assertEqual(binaryinput.state, BinarySensorState.ON)
telegram_off = Telegram()
telegram_off.payload = DPTBinary(0)
self.loop.run_until_complete(asyncio.Task(binaryinput.process(telegram_off)))
self.assertEqual(binaryinput.state, BinarySensorState.OFF)
def test_process_callback(self):
"""Test after_update_callback after state of switch was changed."""
# pylint: disable=no-self-use
xknx = XKNX(loop=self.loop)
switch = BinarySensor(xknx, 'TestInput', group_address_state='1/2/3')
after_update_callback = Mock()
async def async_after_update_callback(device):
"""Async callback."""
after_update_callback(device)
switch.register_device_updated_cb(async_after_update_callback)
telegram = Telegram()
telegram.payload = DPTBinary(1)
self.loop.run_until_complete(asyncio.Task(switch.process(telegram)))
after_update_callback.assert_called_with(switch)
async def service_send_to_knx_bus(self, call):
"""Service for sending an arbitrary KNX message to the KNX bus."""
from xknx.knx import Telegram, GroupAddress, DPTBinary, DPTArray
attr_payload = call.data.get(SERVICE_KNX_ATTR_PAYLOAD)
attr_address = call.data.get(SERVICE_KNX_ATTR_ADDRESS)
def calculate_payload(attr_payload):
"""Calculate payload depending on type of attribute."""
if isinstance(attr_payload, int):
return DPTBinary(attr_payload)
return DPTArray(attr_payload)
payload = calculate_payload(attr_payload)
address = GroupAddress(attr_address)
telegram = Telegram()
telegram.payload = payload
telegram.group_address = address
await self.xknx.telegrams.put(telegram)
def test_cemi_frame(self):
"""Test string representation of KNX/IP CEMI Frame."""
xknx = XKNX(loop=self.loop)
cemi_frame = CEMIFrame(xknx)
cemi_frame.src_addr = GroupAddress("1/2/3")
cemi_frame.telegram = Telegram(group_address=GroupAddress('1/2/5'),
payload=DPTBinary(7))
self.assertEqual(
str(cemi_frame),
'<CEMIFrame SourceAddress="GroupAddress("1/2/3")" DestinationAddress="GroupAddress("1/2/5")" Flags="1011110011100000" Command="APCIC'
'ommand.GROUP_WRITE" payload="<DPTBinary value="7" />" />')
def test_process_percent(self):
"""Test reading percent expose sensor from bus."""
xknx = XKNX(loop=self.loop)
expose_sensor = ExposeSensor(xknx,
'TestSensor',
value_type='percent',
group_address='1/2/3')
expose_sensor.sensor_value.payload = DPTArray((0x40, ))
telegram = Telegram(GroupAddress('1/2/3'))
telegram.telegramtype = TelegramType.GROUP_READ
self.loop.run_until_complete(
asyncio.Task(expose_sensor.process(telegram)))
self.assertEqual(xknx.telegrams.qsize(), 1)
telegram = xknx.telegrams.get_nowait()
self.assertEqual(
telegram,
Telegram(GroupAddress('1/2/3'),
TelegramType.GROUP_RESPONSE,
payload=DPTArray((0x40, ))))
def test_process(self):
"""Test process telegram."""
xknx = XKNX(loop=self.loop)
remote_value = RemoteValueUpDown(xknx,
group_address=GroupAddress("1/2/3"))
telegram = Telegram(group_address=GroupAddress("1/2/3"),
payload=DPTBinary(1))
self.assertEqual(remote_value.value, None)
self.loop.run_until_complete(
asyncio.Task(remote_value.process(telegram)))
self.assertEqual(remote_value.value, RemoteValueUpDown.Direction.DOWN)
def test_process_callback(self):
"""Test process / reading telegrams from telegram queue. Test if callback was called."""
# pylint: disable=no-self-use
xknx = XKNX(loop=self.loop)
switch = Switch(xknx, 'TestOutlet', group_address='1/2/3')
after_update_callback = Mock()
async def async_after_update_callback(device):
"""Async callback."""
after_update_callback(device)
switch.register_device_updated_cb(async_after_update_callback)
telegram = Telegram()
telegram.group_address = GroupAddress('1/2/3')
telegram.payload = DPTBinary(1)
self.loop.run_until_complete(asyncio.Task(switch.process(telegram)))
after_update_callback.assert_called_with(switch)
async def service_send_to_knx_bus(self, call):
"""Service for sending an arbitrary KNX message to the KNX bus."""
from xknx.knx import Telegram, GroupAddress, DPTBinary, DPTArray
attr_payload = call.data.get(SERVICE_KNX_ATTR_PAYLOAD)
attr_address = call.data.get(SERVICE_KNX_ATTR_ADDRESS)
def calculate_payload(attr_payload):
"""Calculate payload depending on type of attribute."""
if isinstance(attr_payload, int):
return DPTBinary(attr_payload)
return DPTArray(attr_payload)
payload = calculate_payload(attr_payload)
address = GroupAddress(attr_address)
telegram = Telegram()
telegram.payload = payload
telegram.group_address = address
await self.xknx.telegrams.put(telegram)
def test_process_operation_mode(self):
"""Test process / reading telegrams from telegram queue. Test if setpoint is processed correctly."""
xknx = XKNX(loop=self.loop)
climate_mode = ClimateMode(
xknx,
'TestClimate',
group_address_operation_mode='1/2/5',
group_address_controller_status='1/2/3')
for operation_mode in DPT_20102_MODES:
telegram = Telegram(GroupAddress('1/2/5'))
telegram.payload = DPTArray(DPTHVACMode.to_knx(operation_mode))
self.loop.run_until_complete(asyncio.Task(climate_mode.process(telegram)))
self.assertEqual(climate_mode.operation_mode, operation_mode)
for operation_mode in DPT_20102_MODES:
if operation_mode == HVACOperationMode.AUTO:
continue
telegram = Telegram(GroupAddress('1/2/3'))
telegram.payload = DPTArray(DPTControllerStatus.to_knx(operation_mode))
self.loop.run_until_complete(asyncio.Task(climate_mode.process(telegram)))
self.assertEqual(climate_mode.operation_mode, operation_mode)
def test_process_callback_temp(self):
"""Test process / reading telegrams from telegram queue. Test if callback is executed when receiving temperature."""
# pylint: disable=no-self-use
xknx = XKNX(loop=self.loop)
climate = Climate(
xknx,
'TestClimate',
group_address_temperature='1/2/3')
after_update_callback = Mock()
async def async_after_update_callback(device):
"""Async callback."""
after_update_callback(device)
climate.register_device_updated_cb(async_after_update_callback)
telegram = Telegram(GroupAddress('1/2/3'))
telegram.payload = DPTArray(DPTTemperature().to_knx(21.34))
self.loop.run_until_complete(asyncio.Task(climate.process(telegram)))
after_update_callback.assert_called_with(climate)
def telegram(self):
"""Return telegram."""
telegram = Telegram()
telegram.payload = self.payload
telegram.group_address = self.dst_addr
def resolve_telegram_type(cmd):
"""Return telegram type from APCI Command."""
if cmd == APCICommand.GROUP_WRITE:
return TelegramType.GROUP_WRITE
if cmd == APCICommand.GROUP_READ:
return TelegramType.GROUP_READ
if cmd == APCICommand.GROUP_RESPONSE:
return TelegramType.GROUP_RESPONSE
raise ConversionError("Telegram not implemented for {0}".format(self.cmd))
telegram.telegramtype = resolve_telegram_type(self.cmd)
# TODO: Set telegram.direction [additional flag within KNXIP]
return telegram
def test_process_callback_updated_via_telegram(self):
"""Test if after_update_callback is called after update of Climate object."""
# pylint: disable=no-self-use
xknx = XKNX(loop=self.loop)
climate = Climate(xknx,
'TestClimate',
group_address_temperature='1/2/1',
group_address_target_temperature='1/2/2',
group_address_setpoint_shift='1/2/3',
group_address_operation_mode='1/2/4')
after_update_callback = Mock()
async def async_after_update_callback(device):
"""Async callback."""
after_update_callback(device)
climate.register_device_updated_cb(async_after_update_callback)
telegram = Telegram(GroupAddress('1/2/1'),
payload=DPTArray(DPTTemperature.to_knx(23)))
self.loop.run_until_complete(asyncio.Task(climate.process(telegram)))
after_update_callback.assert_called_with(climate)
after_update_callback.reset_mock()
telegram = Telegram(GroupAddress('1/2/2'),
payload=DPTArray(DPTTemperature.to_knx(23)))
self.loop.run_until_complete(asyncio.Task(climate.process(telegram)))
after_update_callback.assert_called_with(climate)
after_update_callback.reset_mock()
telegram = Telegram(GroupAddress('1/2/3'),
payload=DPTArray(DPTValue1Count.to_knx(-4)))
self.loop.run_until_complete(asyncio.Task(climate.process(telegram)))
after_update_callback.assert_called_with(climate)
after_update_callback.reset_mock()
telegram = Telegram(GroupAddress('1/2/4'), payload=DPTArray(1))
self.loop.run_until_complete(asyncio.Task(climate.process(telegram)))
after_update_callback.assert_called_with(climate)
after_update_callback.reset_mock()
def test_sync(self):
"""Test sync function / sending group reads to KNX bus."""
xknx = XKNX(loop=self.loop)
fan = Fan(xknx, name="TestFan", group_address_speed_state='1/2/3')
self.loop.run_until_complete(asyncio.Task(fan.sync(False)))
self.assertEqual(xknx.telegrams.qsize(), 1)
telegram1 = xknx.telegrams.get_nowait()
self.assertEqual(
telegram1, Telegram(GroupAddress('1/2/3'),
TelegramType.GROUP_READ))
def test_set(self):
"""Test setting value."""
xknx = XKNX(loop=self.loop)
remote_value = RemoteValueColorRGB(xknx,
group_address=GroupAddress("1/2/3"))
self.loop.run_until_complete(
asyncio.Task(remote_value.set((100, 101, 102))))
self.assertEqual(xknx.telegrams.qsize(), 1)
telegram = xknx.telegrams.get_nowait()
self.assertEqual(
telegram,
Telegram(GroupAddress('1/2/3'),
payload=DPTArray((0x64, 0x65, 0x66))))
self.loop.run_until_complete(
asyncio.Task(remote_value.set((100, 101, 104))))
self.assertEqual(xknx.telegrams.qsize(), 1)
telegram = xknx.telegrams.get_nowait()
self.assertEqual(
telegram,
Telegram(GroupAddress('1/2/3'),
payload=DPTArray((0x64, 0x65, 0x68))))
def test_process_off(self):
"""Test process OFF telegram."""
xknx = XKNX(loop=self.loop)
remote_value = RemoteValueSwitch(xknx,
group_address=GroupAddress("1/2/3"))
telegram = Telegram(group_address=GroupAddress("1/2/3"),
payload=DPTBinary(0))
self.assertEqual(remote_value.value, None)
self.loop.run_until_complete(
asyncio.Task(remote_value.process(telegram)))
self.assertIsNotNone(remote_value.payload)
self.assertEqual(remote_value.value, False)
def test_process_tunable_white(self):
"""Test process / reading telegrams from telegram queue. Test if tunable white is processed."""
xknx = XKNX(loop=self.loop)
light = Light(xknx,
name="TestLight",
group_address_switch='1/2/3',
group_address_tunable_white='1/2/5')
self.assertEqual(light.current_tunable_white, None)
telegram = Telegram(GroupAddress('1/2/5'), payload=DPTArray(23))
self.loop.run_until_complete(asyncio.Task(light.process(telegram)))
self.assertEqual(light.current_tunable_white, 23)
def test_process_color_temperature(self):
"""Test process / reading telegrams from telegram queue. Test if color temperature is processed."""
xknx = XKNX(loop=self.loop)
light = Light(xknx,
name="TestLight",
group_address_switch='1/2/3',
group_address_color_temperature='1/2/5')
self.assertEqual(light.current_color_temperature, None)
telegram = Telegram(GroupAddress('1/2/5'), payload=DPTArray((0x0F, 0xA0, )))
self.loop.run_until_complete(asyncio.Task(light.process(telegram)))
self.assertEqual(light.current_color_temperature, 4000)
def test_set_color_temp(self):
"""Test setting the color temperature value of a Light."""
xknx = XKNX(loop=self.loop)
light = Light(xknx,
name="TestLight",
group_address_switch='1/2/3',
group_address_color_temperature='1/2/5')
self.loop.run_until_complete(asyncio.Task(light.set_color_temperature(4000)))
self.assertEqual(xknx.telegrams.qsize(), 1)
telegram = xknx.telegrams.get_nowait()
self.assertEqual(telegram,
Telegram(GroupAddress('1/2/5'), payload=DPTArray((0x0F, 0xA0, ))))
def test_process_color_rgbw(self):
"""Test process / reading telegrams from telegram queue. Test if RGBW is processed."""
xknx = XKNX(loop=self.loop)
light = Light(xknx,
name="TestLight",
group_address_switch='1/2/3',
group_address_color='1/2/4',
group_address_rgbw='1/2/5')
self.assertEqual(light.current_color, (None, None))
telegram = Telegram(GroupAddress('1/2/5'), payload=DPTArray((0, 15, 23, 24, 25, 26)))
self.loop.run_until_complete(asyncio.Task(light.process(telegram)))
self.assertEqual(light.current_color, ([23, 24, 25], 26))
def test_sync_state(self):
"""Test sync function / sending group reads to KNX bus."""
xknx = XKNX(loop=self.loop)
notification = Notification(
xknx,
"Warning",
group_address='1/2/3')
self.loop.run_until_complete(asyncio.Task(notification.sync(False)))
self.assertEqual(xknx.telegrams.qsize(), 1)
telegram = xknx.telegrams.get_nowait()
self.assertEqual(telegram,
Telegram(GroupAddress('1/2/3'), TelegramType.GROUP_READ))
def test_set_tw(self):
"""Test setting the tunable white value of a Light."""
xknx = XKNX(loop=self.loop)
light = Light(xknx,
name="TestLight",
group_address_switch='1/2/3',
group_address_tunable_white='1/2/5')
self.loop.run_until_complete(asyncio.Task(light.set_tunable_white(23)))
self.assertEqual(xknx.telegrams.qsize(), 1)
telegram = xknx.telegrams.get_nowait()
self.assertEqual(telegram,
Telegram(GroupAddress('1/2/5'), payload=DPTArray(23)))
def sync_state(self):
if self.group_address_position_feedback is None:
print("group_position not defined for device {0}" \
.format(self.get_name()))
return
if self.travelcalculator.is_traveling():
# Cover is traveling, requesting state will return false results
return
telegram = Telegram(self.group_address_position_feedback,
TelegramType.GROUP_READ)
self.xknx.telegrams.put_nowait(telegram)
def telegram(self):
"""Return telegram."""
telegram = Telegram()
telegram.payload = self.payload
telegram.group_address = self.dst_addr
def resolve_telegram_type(cmd):
"""Return telegram type from APCI Command."""
if cmd == APCICommand.GROUP_WRITE:
return TelegramType.GROUP_WRITE
if cmd == APCICommand.GROUP_READ:
return TelegramType.GROUP_READ
if cmd == APCICommand.GROUP_RESPONSE:
return TelegramType.GROUP_RESPONSE
raise ConversionError("Telegram not implemented for {0}".format(
self.cmd))
telegram.telegramtype = resolve_telegram_type(self.cmd)
# TODO: Set telegram.direction [additional flag within KNXIP]
return telegram
def test_process_callback_temp(self):
"""Test process / reading telegrams from telegram queue. Test if callback is executed when receiving temperature."""
# pylint: disable=no-self-use
xknx = XKNX(loop=self.loop)
climate = Climate(
xknx,
'TestClimate',
group_address_temperature='1/2/3')
after_update_callback = Mock()
@asyncio.coroutine
def async_after_update_callback(device):
"""Async callback."""
after_update_callback(device)
climate.register_device_updated_cb(async_after_update_callback)
telegram = Telegram(Address('1/2/3'))
telegram.payload = DPTArray(DPTTemperature().to_knx(21.34))
self.loop.run_until_complete(asyncio.Task(climate.process(telegram)))
after_update_callback.assert_called_with(climate)
def test_maximum_apci(self):
telegram = Telegram()
telegram.group_address = Address(337)
telegram.payload = DPTBinary(DPTBinary.APCI_MAX_VALUE)
knxipframe = KNXIPFrame()
knxipframe.init(KNXIPServiceType.ROUTING_INDICATION)
knxipframe.body.src_addr = Address("1.3.1")
knxipframe.body.telegram = telegram
knxipframe.body.set_hops(5)
knxipframe.normalize()
raw = ((0x06, 0x10, 0x05, 0x30, 0x00, 0x11, 0x29, 0x00,
0xbc, 0xd0, 0x13, 0x01, 0x01, 0x51, 0x01, 0x00,
0xbf))
self.assertEqual(knxipframe.to_knx(), list(raw))
knxipframe2 = KNXIPFrame()
knxipframe2.init(KNXIPServiceType.ROUTING_INDICATION)
knxipframe2.from_knx(knxipframe.to_knx())
self.assertEqual(knxipframe2.body.telegram, telegram)
def test_process_temperature(self):
"""Test reading temperature expose sensor from bus."""
xknx = XKNX(loop=self.loop)
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'))
telegram.telegramtype = TelegramType.GROUP_READ
self.loop.run_until_complete(asyncio.Task(expose_sensor.process(telegram)))
self.assertEqual(xknx.telegrams.qsize(), 1)
telegram = xknx.telegrams.get_nowait()
self.assertEqual(
telegram,
Telegram(
GroupAddress('1/2/3'),
TelegramType.GROUP_RESPONSE,
payload=DPTArray((0x0c, 0x1a))))
def test_set(self):
"""Test notificationing off notification."""
xknx = XKNX(loop=self.loop)
notification = Notification(xknx, 'Warning', group_address='1/2/3')
self.loop.run_until_complete(
asyncio.Task(notification.set("Ein Prosit!")))
self.assertEqual(xknx.telegrams.qsize(), 1)
telegram = xknx.telegrams.get_nowait()
self.assertEqual(
telegram,
Telegram(GroupAddress('1/2/3'),
payload=DPTArray(DPTString().to_knx("Ein Prosit!"))))
def test_do(self):
"""Test running scene with do command."""
xknx = XKNX(loop=self.loop)
scene = Scene(xknx,
'TestScene',
group_address='1/2/1',
scene_number=23)
self.loop.run_until_complete(asyncio.Task(scene.do("run")))
self.assertEqual(xknx.telegrams.qsize(), 1)
telegram = xknx.telegrams.get_nowait()
self.assertEqual(
telegram, Telegram(GroupAddress('1/2/1'), payload=DPTArray(0x16)))
def test_process_callback(self):
"""Test process / reading telegrams from telegram queue. Test if callback was called."""
# pylint: disable=no-self-use
xknx = XKNX(loop=self.loop)
switch = Switch(xknx, 'TestOutlet', group_address='1/2/3')
after_update_callback = Mock()
async def async_after_update_callback(device):
"""Async callback."""
after_update_callback(device)
switch.register_device_updated_cb(async_after_update_callback)
telegram = Telegram()
telegram.group_address = GroupAddress('1/2/3')
telegram.payload = DPTBinary(1)
self.loop.run_until_complete(asyncio.Task(switch.process(telegram)))
after_update_callback.assert_called_with(switch)
def test_set_brightness(self):
xknx = XKNX(self.loop, start=False)
light = Light(xknx,
name="TestLight",
group_address_switch='1/2/3',
group_address_dimm='1/2/4',
group_address_brightness='1/2/5')
light.set_brightness(23)
self.assertEqual(xknx.telegrams.qsize(), 1)
telegram = xknx.telegrams.get_nowait()
self.assertEqual(telegram,
Telegram(Address('1/2/5'), payload=DPTArray(23)))
def test_process_callback(self):
"""Test process / reading telegrams from telegram queue. Test if callback is called."""
# pylint: disable=no-self-use
xknx = XKNX(loop=self.loop)
sensor = Sensor(
xknx,
'TestSensor',
group_address_state='1/2/3',
value_type="temperature")
after_update_callback = Mock()
async def async_after_update_callback(device):
"""Async callback."""
after_update_callback(device)
sensor.register_device_updated_cb(async_after_update_callback)
telegram = Telegram(GroupAddress('1/2/3'))
telegram.payload = DPTArray((0x01, 0x02))
self.loop.run_until_complete(asyncio.Task(sensor.process(telegram)))
after_update_callback.assert_called_with(sensor)
def test_sync(self):
"""Test sync function / sending group reads to KNX bus."""
xknx = XKNX(loop=self.loop)
sensor = Sensor(xknx, 'TestSensor', group_address='1/2/3')
self.loop.run_until_complete(asyncio.Task(sensor.sync(False)))
self.assertEqual(xknx.telegrams.qsize(), 1)
telegram = xknx.telegrams.get_nowait()
self.assertEqual(telegram,
Telegram(Address('1/2/3'), TelegramType.GROUP_READ))
def test_process_dimm(self):
xknx = XKNX(self.loop, start=False)
light = Light(xknx,
name="TestLight",
group_address_switch='1/2/3',
group_address_dimm='1/2/4',
group_address_brightness='1/2/5')
self.assertEqual(light.brightness, 0)
telegram = Telegram(Address('1/2/5'), payload=DPTArray(23))
light.process(telegram)
self.assertEqual(light.brightness, 23)
def test_process_dimm(self):
"""Test process / reading telegrams from telegram queue. Test if brightness is processed."""
xknx = XKNX(loop=self.loop)
light = Light(xknx,
name="TestLight",
group_address_switch='1/2/3',
group_address_brightness='1/2/5')
self.assertEqual(light.brightness, 0)
telegram = Telegram(Address('1/2/5'), payload=DPTArray(23))
self.loop.run_until_complete(asyncio.Task(light.process(telegram)))
self.assertEqual(light.brightness, 23)
def test_set_on(self):
"""Test switching on a Light."""
xknx = XKNX(loop=self.loop)
light = Light(xknx,
name="TestLight",
group_address_switch='1/2/3',
group_address_brightness='1/2/5')
self.loop.run_until_complete(asyncio.Task(light.set_on()))
self.assertEqual(xknx.telegrams.qsize(), 1)
telegram = xknx.telegrams.get_nowait()
self.assertEqual(telegram,
Telegram(Address('1/2/3'), payload=DPTBinary(1)))
def test_process_callback(self):
"""Test process / reading telegrams from telegram queue. Test if callback is called."""
# pylint: disable=no-self-use
xknx = XKNX(loop=self.loop)
sensor = Sensor(
xknx,
'TestSensor',
group_address='1/2/3',
value_type="temperature")
after_update_callback = Mock()
async def async_after_update_callback(device):
"""Async callback."""
after_update_callback(device)
sensor.register_device_updated_cb(async_after_update_callback)
telegram = Telegram(GroupAddress('1/2/3'))
telegram.payload = DPTArray((0x01, 0x02))
self.loop.run_until_complete(asyncio.Task(sensor.process(telegram)))
after_update_callback.assert_called_with(sensor)
def test_maximum_apci(self):
"""Test parsing and streaming CEMIFrame KNX/IP packet, testing maximum APCI."""
telegram = Telegram()
telegram.group_address = GroupAddress(337)
telegram.payload = DPTBinary(DPTBinary.APCI_MAX_VALUE)
xknx = XKNX(loop=self.loop)
knxipframe = KNXIPFrame(xknx)
knxipframe.init(KNXIPServiceType.ROUTING_INDICATION)
knxipframe.body.src_addr = PhysicalAddress("1.3.1")
knxipframe.body.telegram = telegram
knxipframe.body.set_hops(5)
knxipframe.normalize()
raw = ((0x06, 0x10, 0x05, 0x30, 0x00, 0x11, 0x29, 0x00, 0xbc, 0xd0,
0x13, 0x01, 0x01, 0x51, 0x01, 0x00, 0xbf))
self.assertEqual(knxipframe.to_knx(), list(raw))
knxipframe2 = KNXIPFrame(xknx)
knxipframe2.init(KNXIPServiceType.ROUTING_INDICATION)
knxipframe2.from_knx(knxipframe.to_knx())
self.assertEqual(knxipframe2.body.telegram, telegram)
def test_process_angle(self):
"""Test process / reading telegrams from telegram queue. Test if position is processed correctly."""
xknx = XKNX(loop=self.loop)
cover = Cover(xknx,
'TestCover',
group_address_long='1/2/1',
group_address_short='1/2/2',
group_address_angle='1/2/3',
group_address_angle_state='1/2/4')
telegram = Telegram(GroupAddress('1/2/4'), payload=DPTArray(42))
self.loop.run_until_complete(asyncio.Task(cover.process(telegram)))
self.assertEqual(cover.current_angle(), 84)
def test_sync(self):
"""Test sync function / sending group reads to KNX bus."""
xknx = XKNX(loop=self.loop)
climate = Climate(xknx,
'TestClimate',
group_address_temperature='1/2/3')
self.loop.run_until_complete(asyncio.Task(climate.sync(False)))
self.assertEqual(xknx.telegrams.qsize(), 1)
telegram1 = xknx.telegrams.get_nowait()
self.assertEqual(
telegram1, Telegram(GroupAddress('1/2/3'),
TelegramType.GROUP_READ))
def test_process(self):
"""Test process / reading telegrams from telegram queue. Test if device was updated."""
xknx = XKNX(loop=self.loop)
switch = Switch(xknx, 'TestOutlet', group_address='1/2/3')
self.assertEqual(switch.state, False)
telegram_on = Telegram()
telegram_on.group_address = GroupAddress('1/2/3')
telegram_on.payload = DPTBinary(1)
self.loop.run_until_complete(asyncio.Task(switch.process(telegram_on)))
self.assertEqual(switch.state, True)
telegram_off = Telegram()
telegram_off.group_address = GroupAddress('1/2/3')
telegram_off.payload = DPTBinary(0)
self.loop.run_until_complete(asyncio.Task(switch.process(telegram_off)))
self.assertEqual(switch.state, False)
def test_process_significant_bit(self):
"""Test process / reading telegrams from telegram queue with specific significant bit set."""
xknx = XKNX(loop=self.loop)
binaryinput = BinarySensor(xknx, 'TestInput', '1/2/3', significant_bit=3)
self.assertEqual(binaryinput.state, BinarySensorState.OFF)
# Wrong significant bit: 0000 1011 = 11
telegram_on = Telegram()
telegram_on.payload = DPTBinary(11)
self.loop.run_until_complete(asyncio.Task(binaryinput.process(telegram_on)))
self.assertEqual(binaryinput.state, BinarySensorState.OFF)
# Correct significant bit: 0000 1101 = 13
telegram_on = Telegram()
telegram_on.payload = DPTBinary(13)
self.loop.run_until_complete(asyncio.Task(binaryinput.process(telegram_on)))
self.assertEqual(binaryinput.state, BinarySensorState.ON)
# Resetting, significant bit: 0000 0011 = 3
telegram_off = Telegram()
telegram_off.payload = DPTBinary(3)
self.loop.run_until_complete(asyncio.Task(binaryinput.process(telegram_off)))
self.assertEqual(binaryinput.state, BinarySensorState.OFF)
