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_len(self):
"""Test len() function."""
xknx = XKNX(loop=self.loop)
devices = Devices()
self.assertEqual(len(devices), 0)
light1 = Light(xknx,
'Living-Room.Light_1',
group_address_switch='1/6/7')
devices.add(light1)
self.assertEqual(len(devices), 1)
sensor1 = BinarySensor(xknx,
'DiningRoom.Motion.Sensor',
group_address_state='3/0/1',
significant_bit=2)
devices.add(sensor1)
self.assertEqual(len(devices), 2)
sensor2 = BinarySensor(xknx,
'DiningRoom.Motion.Sensor',
group_address_state='3/0/1',
significant_bit=3)
devices.add(sensor2)
self.assertEqual(len(devices), 3)
light2 = Light(xknx,
'Living-Room.Light_2',
group_address_switch='1/6/8')
devices.add(light2)
self.assertEqual(len(devices), 4)
def test_device_by_group_address(self):
"""Test get devices by group address."""
xknx = XKNX()
devices = Devices()
light1 = Light(xknx,
"Living-Room.Light_1",
group_address_switch="1/6/7")
devices.add(light1)
sensor1 = BinarySensor(xknx,
"DiningRoom.Motion.Sensor",
group_address_state="3/0/1")
devices.add(sensor1)
sensor2 = BinarySensor(xknx,
"DiningRoom.Motion.Sensor",
group_address_state="3/0/1")
devices.add(sensor2)
light2 = Light(xknx,
"Living-Room.Light_2",
group_address_switch="1/6/8")
devices.add(light2)
self.assertEqual(
tuple(devices.devices_by_group_address(GroupAddress("1/6/7"))),
(light1, ))
self.assertEqual(
tuple(devices.devices_by_group_address(GroupAddress("1/6/8"))),
(light2, ))
self.assertEqual(
tuple(devices.devices_by_group_address(GroupAddress("3/0/1"))),
(sensor1, sensor2),
)
def test_device_by_group_address(self):
"""Test get devices by group address."""
xknx = XKNX(loop=self.loop)
devices = Devices()
light1 = Light(xknx,
'Living-Room.Light_1',
group_address_switch='1/6/7')
devices.add(light1)
sensor1 = BinarySensor(xknx,
'DiningRoom.Motion.Sensor',
group_address_state='3/0/1')
devices.add(sensor1)
sensor2 = BinarySensor(xknx,
'DiningRoom.Motion.Sensor',
group_address_state='3/0/1')
devices.add(sensor2)
light2 = Light(xknx,
'Living-Room.Light_2',
group_address_switch='1/6/8')
devices.add(light2)
self.assertEqual(
tuple(devices.devices_by_group_address(GroupAddress('1/6/7'))),
(light1, ))
self.assertEqual(
tuple(devices.devices_by_group_address(GroupAddress('1/6/8'))),
(light2, ))
self.assertEqual(
tuple(devices.devices_by_group_address(GroupAddress('3/0/1'))),
(sensor1, sensor2))
def test_process_wrong_payload(self):
"""Test process wrong telegram (wrong payload type)."""
xknx = XKNX(loop=self.loop)
binary_sensor = BinarySensor(xknx, 'Warning', group_address_state='1/2/3')
telegram = Telegram(GroupAddress('1/2/3'), payload=DPTArray((0x1, 0x2, 0x3)))
with self.assertRaises(CouldNotParseTelegram):
self.loop.run_until_complete(asyncio.Task(binary_sensor.process(telegram)))
def test_iter(self):
"""Test __iter__() function."""
xknx = XKNX()
devices = Devices()
light1 = Light(xknx,
"Living-Room.Light_1",
group_address_switch="1/6/7")
devices.add(light1)
sensor1 = BinarySensor(xknx,
"DiningRoom.Motion.Sensor",
group_address_state="3/0/1")
devices.add(sensor1)
sensor2 = BinarySensor(xknx,
"DiningRoom.Motion.Sensor",
group_address_state="3/0/1")
devices.add(sensor2)
light2 = Light(xknx,
"Living-Room.Light_2",
group_address_switch="1/6/8")
devices.add(light2)
self.assertEqual(tuple(devices.__iter__()),
(light1, sensor1, sensor2, light2))
async def test_process(self):
"""Test process / reading telegrams from telegram queue."""
xknx = XKNX()
binaryinput = BinarySensor(xknx, "TestInput", "1/2/3")
assert binaryinput.state is None
telegram_on = Telegram(
destination_address=GroupAddress("1/2/3"),
payload=GroupValueWrite(DPTBinary(1)),
)
await binaryinput.process(telegram_on)
assert binaryinput.state is True
telegram_off = Telegram(
destination_address=GroupAddress("1/2/3"),
payload=GroupValueWrite(DPTBinary(0)),
)
await binaryinput.process(telegram_off)
assert binaryinput.state is False
binaryinput2 = BinarySensor(xknx, "TestInput", "1/2/4")
assert binaryinput2.state is None
telegram_off2 = Telegram(
destination_address=GroupAddress("1/2/4"),
payload=GroupValueWrite(DPTBinary(0)),
)
await binaryinput2.process(telegram_off2)
assert binaryinput2.last_telegram == telegram_off2
assert binaryinput2.state is False
async def test_process_callback_ignore_internal_state_no_counter(self):
"""Test after_update_callback after state of switch was changed."""
xknx = XKNX()
switch = BinarySensor(
xknx,
"TestInput",
group_address_state="1/2/3",
ignore_internal_state=True,
context_timeout=0,
)
async_after_update_callback = AsyncMock()
switch.register_device_updated_cb(async_after_update_callback)
telegram = Telegram(
destination_address=GroupAddress("1/2/3"),
payload=GroupValueWrite(DPTBinary(1)),
)
await switch.process(telegram)
# no _context_task started because context_timeout is False
assert switch._context_task is None
async_after_update_callback.assert_called_once_with(switch)
async_after_update_callback.reset_mock()
# send same telegram again
await switch.process(telegram)
async_after_update_callback.assert_called_once_with(switch)
def test_process_wrong_payload(self):
"""Test process wrong telegram (wrong payload type)."""
xknx = XKNX(loop=self.loop)
binary_sensor = BinarySensor(xknx, 'Warning', group_address_state='1/2/3')
telegram = Telegram(GroupAddress('1/2/3'), payload=DPTArray((0x1, 0x2, 0x3)))
with self.assertRaises(CouldNotParseTelegram):
self.loop.run_until_complete(asyncio.Task(binary_sensor.process(telegram)))
def test_process_reset_after(self):
"""Test process / reading telegrams from telegram queue."""
xknx = XKNX()
reset_after_sec = 0.001
async_after_update_callback = AsyncMock()
binaryinput = BinarySensor(
xknx,
"TestInput",
"1/2/3",
reset_after=reset_after_sec,
device_updated_cb=async_after_update_callback,
)
telegram_on = Telegram(group_address=GroupAddress("1/2/3"),
payload=DPTBinary(1))
self.loop.run_until_complete(binaryinput.process(telegram_on))
self.assertTrue(binaryinput.state)
self.loop.run_until_complete(asyncio.sleep(reset_after_sec * 1.1))
self.assertFalse(binaryinput.state)
# once for 'on' and once for 'off'
self.assertEqual(async_after_update_callback.call_count, 2)
async_after_update_callback.reset_mock()
# multiple telegrams during reset_after time period shall reset timer
self.loop.run_until_complete(binaryinput.process(telegram_on))
async_after_update_callback.assert_called_once()
self.loop.run_until_complete(binaryinput.process(telegram_on))
self.loop.run_until_complete(binaryinput.process(telegram_on))
# second and third telegram resets timer but doesn't run callback
async_after_update_callback.assert_called_once()
self.assertTrue(binaryinput.state)
self.loop.run_until_complete(asyncio.sleep(reset_after_sec * 1.1))
self.assertFalse(binaryinput.state)
# once for 'on' and once for 'off'
self.assertEqual(async_after_update_callback.call_count, 2)
def test_process_reset_after(self):
"""Test process / reading telegrams from telegram queue."""
xknx = XKNX(loop=self.loop)
binaryinput = BinarySensor(xknx, 'TestInput', '1/2/3', reset_after=0.01)
telegram_on = Telegram(payload=DPTBinary(1))
self.loop.run_until_complete(asyncio.Task(binaryinput.process(telegram_on)))
self.assertEqual(binaryinput.state, BinarySensorState.OFF)
def test_process_reset_after(self):
"""Test process / reading telegrams from telegram queue."""
xknx = XKNX(loop=self.loop)
binaryinput = BinarySensor(xknx, 'TestInput', '1/2/3', reset_after=0.01)
telegram_on = Telegram(payload=DPTBinary(1))
self.loop.run_until_complete(asyncio.Task(binaryinput.process(telegram_on)))
self.assertEqual(binaryinput.state, BinarySensorState.OFF)
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)
def test_iter(self):
"""Test __iter__() function."""
xknx = XKNX(loop=self.loop)
devices = Devices()
light1 = Light(xknx,
'Living-Room.Light_1',
group_address_switch='1/6/7')
devices.add(light1)
sensor1 = BinarySensor(xknx,
'DiningRoom.Motion.Sensor',
group_address_state='3/0/1',
significant_bit=2)
devices.add(sensor1)
sensor2 = BinarySensor(xknx,
'DiningRoom.Motion.Sensor',
group_address_state='3/0/1',
significant_bit=3)
devices.add(sensor2)
light2 = Light(xknx,
'Living-Room.Light_2',
group_address_switch='1/6/8')
devices.add(light2)
self.assertEqual(
tuple(devices.__iter__()),
(light1, sensor1, sensor2, light2))
def test_is_off(self):
"""Test is_on() and is_off() of a BinarySensor with state 'off'."""
xknx = XKNX(loop=self.loop)
binaryinput = BinarySensor(xknx, 'TestInput', '1/2/3')
# pylint: disable=protected-access
self.loop.run_until_complete(asyncio.Task(binaryinput._set_internal_state(BinarySensorState.OFF)))
self.assertFalse(binaryinput.is_on())
self.assertTrue(binaryinput.is_off())
async def test_is_off(self):
"""Test is_on() and is_off() of a BinarySensor with state 'off'."""
xknx = XKNX()
binaryinput = BinarySensor(xknx, "TestInput", "1/2/3")
await binaryinput._set_internal_state(False)
assert not binaryinput.is_on()
assert binaryinput.is_off()
def test_state_addresses(self):
"""Test binary sensor returns state address as list."""
xknx = XKNX(loop=self.loop)
binary_sensor = BinarySensor(xknx, 'TestInput', group_address_state='1/2/4')
self.assertEqual(binary_sensor.state_addresses(), [GroupAddress('1/2/4')])
binary_sensor2 = BinarySensor(xknx, 'TestInput')
self.assertEqual(binary_sensor2.state_addresses(), [])
def test_is_off(self):
"""Test is_on() and is_off() of a BinarySensor with state 'off'."""
xknx = XKNX(loop=self.loop)
binaryinput = BinarySensor(xknx, 'TestInput', '1/2/3')
# pylint: disable=protected-access
self.loop.run_until_complete(asyncio.Task(binaryinput._set_internal_state(BinarySensorState.OFF)))
self.assertFalse(binaryinput.is_on())
self.assertTrue(binaryinput.is_off())
def test_is_off(self):
"""Test is_on() and is_off() of a BinarySensor with state 'off'."""
xknx = XKNX()
binaryinput = BinarySensor(xknx, "TestInput", "1/2/3")
# pylint: disable=protected-access
self.loop.run_until_complete(binaryinput._set_internal_state(False))
self.assertFalse(binaryinput.is_on())
self.assertTrue(binaryinput.is_off())
def test_state_addresses(self):
"""Test expose sensor returns empty list as state addresses."""
xknx = XKNX(loop=self.loop)
binary_sensor = BinarySensor(xknx,
'TestInput',
group_address='1/2/3',
group_address_state='1/2/4')
self.assertEqual(binary_sensor.state_addresses(),
[GroupAddress('1/2/4')])
def test_counter(self):
"""Test counter functionality."""
xknx = XKNX(loop=self.loop)
switch = BinarySensor(xknx, "TestInput", group_address_state="1/2/3")
with patch("time.time") as mock_time:
mock_time.return_value = 1517000000.0
self.assertEqual(switch.bump_and_get_counter(True), 1)
mock_time.return_value = 1517000000.1
self.assertEqual(switch.bump_and_get_counter(True), 2)
mock_time.return_value = 1517000000.2
self.assertEqual(switch.bump_and_get_counter(False), 1)
mock_time.return_value = 1517000000.3
self.assertEqual(switch.bump_and_get_counter(True), 3)
mock_time.return_value = 1517000000.4
self.assertEqual(switch.bump_and_get_counter(False), 2)
mock_time.return_value = 1517000002.0 # TIME OUT ...
self.assertEqual(switch.bump_and_get_counter(True), 1)
mock_time.return_value = 1517000004.1 # TIME OUT ...
self.assertEqual(switch.bump_and_get_counter(False), 1)
def test_counter(self):
"""Test counter functionality."""
xknx = XKNX()
switch = BinarySensor(
xknx, "TestInput", group_address_state="1/2/3", context_timeout=1
)
with patch("time.time") as mock_time:
mock_time.return_value = 1517000000.0
assert switch.bump_and_get_counter(True) == 1
mock_time.return_value = 1517000000.1
assert switch.bump_and_get_counter(True) == 2
mock_time.return_value = 1517000000.2
assert switch.bump_and_get_counter(False) == 1
mock_time.return_value = 1517000000.3
assert switch.bump_and_get_counter(True) == 3
mock_time.return_value = 1517000000.4
assert switch.bump_and_get_counter(False) == 2
mock_time.return_value = 1517000002.0 # TIME OUT ...
assert switch.bump_and_get_counter(True) == 1
mock_time.return_value = 1517000004.1 # TIME OUT ...
assert switch.bump_and_get_counter(False) == 1
def test_counter(self):
"""Test counter functionality."""
xknx = XKNX(loop=self.loop)
switch = BinarySensor(xknx, 'TestInput', group_address='1/2/3')
with patch('time.time') as mock_time:
mock_time.return_value = 1517000000.0
self.assertEqual(switch.bump_and_get_counter(BinarySensorState.ON),
1)
mock_time.return_value = 1517000000.1
self.assertEqual(switch.bump_and_get_counter(BinarySensorState.ON),
2)
mock_time.return_value = 1517000000.2
self.assertEqual(
switch.bump_and_get_counter(BinarySensorState.OFF), 1)
mock_time.return_value = 1517000000.3
self.assertEqual(switch.bump_and_get_counter(BinarySensorState.ON),
3)
mock_time.return_value = 1517000000.4
self.assertEqual(
switch.bump_and_get_counter(BinarySensorState.OFF), 2)
mock_time.return_value = 1517000002.0 # TIME OUT ...
self.assertEqual(switch.bump_and_get_counter(BinarySensorState.ON),
1)
mock_time.return_value = 1517000004.1 # TIME OUT ...
self.assertEqual(
switch.bump_and_get_counter(BinarySensorState.OFF), 1)
def test_process_reset_after(self):
"""Test process / reading telegrams from telegram queue."""
xknx = XKNX(loop=self.loop)
reset_after_ms = 0.01
binaryinput = BinarySensor(xknx, 'TestInput', '1/2/3', reset_after=reset_after_ms)
telegram_on = Telegram(group_address=GroupAddress('1/2/3'))
telegram_on.payload = DPTBinary(1)
self.loop.run_until_complete(asyncio.Task(binaryinput.process(telegram_on)))
self.loop.run_until_complete(asyncio.sleep(reset_after_ms*2/1000))
self.assertEqual(binaryinput.state, False)
def test_process_wrong_payload(self):
"""Test process wrong telegram (wrong payload type)."""
xknx = XKNX()
binary_sensor = BinarySensor(xknx,
"Warning",
group_address_state="1/2/3")
telegram = Telegram(
destination_address=GroupAddress("1/2/3"),
payload=GroupValueWrite(DPTArray((0x1, 0x2, 0x3))),
)
with self.assertRaises(CouldNotParseTelegram):
self.loop.run_until_complete(binary_sensor.process(telegram))
def test_process_action_ignore_internal_state(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/5', ignore_internal_state=True)
action_on = Action(
xknx,
hook='on',
target='TestOutlet',
method='on')
binary_sensor.actions.append(action_on)
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)
self.loop.run_until_complete(asyncio.Task(switch.set_off()))
self.assertEqual(
xknx.devices['TestOutlet'].state,
False)
self.assertEqual(
xknx.devices['TestInput'].state,
BinarySensorState.ON)
self.loop.run_until_complete(asyncio.sleep(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)
def test_counter(self):
"""Test counter functionality."""
xknx = XKNX(loop=self.loop)
switch = BinarySensor(xknx, 'TestInput', group_address_state='1/2/3')
with patch('time.time') as mock_time:
mock_time.return_value = 1517000000.0
self.assertEqual(switch.bump_and_get_counter(BinarySensorState.ON), 1)
mock_time.return_value = 1517000000.1
self.assertEqual(switch.bump_and_get_counter(BinarySensorState.ON), 2)
mock_time.return_value = 1517000000.2
self.assertEqual(switch.bump_and_get_counter(BinarySensorState.OFF), 1)
mock_time.return_value = 1517000000.3
self.assertEqual(switch.bump_and_get_counter(BinarySensorState.ON), 3)
mock_time.return_value = 1517000000.4
self.assertEqual(switch.bump_and_get_counter(BinarySensorState.OFF), 2)
mock_time.return_value = 1517000002.0 # TIME OUT ...
self.assertEqual(switch.bump_and_get_counter(BinarySensorState.ON), 1)
mock_time.return_value = 1517000004.1 # TIME OUT ...
self.assertEqual(switch.bump_and_get_counter(BinarySensorState.OFF), 1)
def test_process_reset_after(self):
"""Test process / reading telegrams from telegram queue."""
xknx = XKNX()
reset_after_sec = 0.001
binaryinput = BinarySensor(xknx,
"TestInput",
"1/2/3",
reset_after=reset_after_sec)
telegram_on = Telegram(group_address=GroupAddress("1/2/3"),
payload=DPTBinary(1))
self.loop.run_until_complete(binaryinput.process(telegram_on))
self.loop.run_until_complete(asyncio.sleep(reset_after_sec * 2))
self.assertEqual(binaryinput.state, False)
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,
False)
self.assertEqual(
xknx.devices['TestOutlet'].state,
False)
telegram_on = Telegram(group_address=GroupAddress('1/2/3'))
telegram_on.payload = DPTBinary(1)
self.loop.run_until_complete(asyncio.Task(binary_sensor.process(telegram_on)))
self.assertEqual(
xknx.devices['TestInput'].state,
True)
self.assertEqual(
xknx.devices['TestOutlet'].state,
True)
telegram_off = Telegram(group_address=GroupAddress('1/2/3'))
telegram_off.payload = DPTBinary(0)
self.loop.run_until_complete(asyncio.Task(binary_sensor.process(telegram_off)))
self.assertEqual(
xknx.devices['TestInput'].state,
False)
self.assertEqual(
xknx.devices['TestOutlet'].state,
False)
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_iter(self):
"""Test __iter__() function."""
xknx = XKNX()
devices = Devices()
light1 = Light(xknx, "Livingroom", group_address_switch="1/6/7")
sensor1 = BinarySensor(xknx, "Diningroom", group_address_state="3/0/1")
sensor2 = BinarySensor(xknx, "Diningroom", group_address_state="3/0/1")
light2 = Light(xknx, "Livingroom", group_address_switch="1/6/8")
devices.add(light1)
devices.add(sensor1)
devices.add(sensor2)
devices.add(light2)
assert tuple(devices.__iter__()) == (light1, sensor1, sensor2, light2)
def test_len(self):
"""Test len() function."""
xknx = XKNX()
self.assertEqual(len(xknx.devices), 0)
Light(xknx, "Living-Room.Light_1", group_address_switch="1/6/7")
self.assertEqual(len(xknx.devices), 1)
BinarySensor(xknx, "DiningRoom.Motion.Sensor", group_address_state="3/0/1")
self.assertEqual(len(xknx.devices), 2)
BinarySensor(xknx, "DiningRoom.Motion.Sensor", group_address_state="3/0/1")
self.assertEqual(len(xknx.devices), 3)
Light(xknx, "Living-Room.Light_2", group_address_switch="1/6/8")
self.assertEqual(len(xknx.devices), 4)
def test_unique_id(self):
"""Test unique id functionality."""
xknx = XKNX()
switch = BinarySensor(
xknx, "TestInput", group_address_state="1/2/3", context_timeout=1
)
assert switch.unique_id == "1/2/3"
def async_add_entities_config(hass, config, async_add_entities):
"""Set up binary senor for KNX platform configured within platform."""
name = config[CONF_NAME]
binary_sensor = BinarySensor(
hass.data[DATA_KNX].xknx,
name=name,
group_address_state=config[CONF_STATE_ADDRESS],
sync_state=config[CONF_SYNC_STATE],
device_class=config.get(CONF_DEVICE_CLASS),
significant_bit=config[CONF_SIGNIFICANT_BIT],
reset_after=config.get(CONF_RESET_AFTER),
)
hass.data[DATA_KNX].xknx.devices.add(binary_sensor)
entity = KNXBinarySensor(binary_sensor)
automations = config.get(CONF_AUTOMATION)
if automations is not None:
for automation in automations:
counter = automation[CONF_COUNTER]
hook = automation[CONF_HOOK]
action = automation[CONF_ACTION]
entity.automations.append(
KNXAutomation(
hass=hass,
device=binary_sensor,
hook=hook,
action=action,
counter=counter,
))
async_add_entities([entity])
async def main():
"""Connect to KNX/IP device and read the value of a temperature and a motion sensor."""
xknx = XKNX()
await xknx.start()
sensor1 = BinarySensor(
xknx,
"DiningRoom.Motion.Sensor",
group_address_state="6/0/2",
device_class="motion",
)
await sensor1.sync()
print(sensor1)
sensor2 = Sensor(
xknx,
"DiningRoom.Temperature.Sensor",
group_address_state="6/2/1",
value_type="temperature",
)
await sensor2.sync()
print(sensor2)
await xknx.stop()
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)
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)
def parse_group_binary_sensor(self, entries):
"""Parse a binary_sensor section of xknx.yaml."""
for entry in entries:
binary_sensor = BinarySensor.from_config(
self.xknx,
entry,
entries[entry])
self.xknx.devices.add(binary_sensor)
def test_binary_sensor_loop(self):
"""Test binary_sensor and expose_sensor with binary values."""
test_cases = [
('binary', DPTBinary(0), False),
('binary', DPTBinary(1), True),
]
for value_type, test_payload, test_value in test_cases:
with self.subTest(value_type=value_type):
xknx = XKNX(loop=self.loop)
sensor = BinarySensor(
xknx,
'TestSensor_%s' % value_type,
group_address_state='1/1/1'
)
expose = ExposeSensor(
xknx,
'TestExpose_%s' % value_type,
group_address='2/2/2',
value_type=value_type
)
incoming_telegram = Telegram(GroupAddress('1/1/1'),
TelegramType.GROUP_WRITE,
direction=TelegramDirection.INCOMING,
payload=test_payload)
self.loop.run_until_complete(asyncio.Task(sensor.process(incoming_telegram)))
incoming_value = sensor.is_on()
self.assertEqual(incoming_value, test_value)
self.loop.run_until_complete(asyncio.Task(expose.set(test_value)))
self.assertEqual(xknx.telegrams.qsize(), 1)
outgoing_telegram = xknx.telegrams.get_nowait()
self.assertEqual(
outgoing_telegram,
Telegram(
GroupAddress('2/2/2'),
TelegramType.GROUP_WRITE,
direction=TelegramDirection.OUTGOING,
payload=test_payload))
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)
