def test_auto_stop(self):
"""Test auto stop functionality."""
xknx = XKNX(loop=self.loop)
cover = Cover(
xknx,
'TestCover',
group_address_long='1/2/1',
travel_time_down=10,
travel_time_up=10)
with patch('xknx.devices.Cover.stop') as mock_stop, patch('time.time') as mock_time:
fut = asyncio.Future()
fut.set_result(None)
mock_stop.return_value = fut
mock_time.return_value = 1517000000.0
self.loop.run_until_complete(asyncio.Task(cover.set_position(50)))
mock_time.return_value = 1517000001.0
self.loop.run_until_complete(asyncio.Task(cover.auto_stop_if_necessary()))
mock_stop.assert_not_called()
mock_time.return_value = 1517000005.0
self.loop.run_until_complete(asyncio.Task(cover.auto_stop_if_necessary()))
mock_stop.assert_called_with()
mock_stop.reset_mock()
def test_wrong_do(self):
"""Test wrong do command."""
xknx = XKNX(loop=self.loop)
cover = Cover(
xknx,
'TestCover')
with patch('logging.Logger.warning') as mock_warn:
self.loop.run_until_complete(asyncio.Task(cover.do("execute")))
self.assertEqual(xknx.telegrams.qsize(), 0)
mock_warn.assert_called_with('Could not understand action %s for device %s', 'execute', 'TestCover')
def test_angle_not_supported(self):
"""Test changing angle on cover wich does not support angle."""
xknx = XKNX(loop=self.loop)
cover = Cover(
xknx,
'Children.Venetian',
group_address_long='1/4/14',
group_address_short='1/4/15')
with patch('logging.Logger.warning') as mock_warn:
self.loop.run_until_complete(asyncio.Task(cover.set_angle(50)))
self.assertEqual(xknx.telegrams.qsize(), 0)
mock_warn.assert_called_with('Angle not supported for device %s', 'Children.Venetian')
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_state_addresses(self):
"""Test state addresses of cover."""
xknx = XKNX(loop=self.loop)
cover = Cover(
xknx,
'TestCover',
group_address_long='1/2/1',
group_address_short='1/2/2',
group_address_position='1/2/3',
group_address_position_state='1/2/4',
group_address_angle='1/2/5',
group_address_angle_state='1/2/6')
self.assertEqual(cover.state_addresses(), [GroupAddress('1/2/4'), GroupAddress('1/2/6')])
def test_stop(self):
"""Test stopping cover."""
xknx = XKNX(loop=self.loop)
cover = Cover(
xknx, 'TestCover',
group_address_long='1/2/1',
group_address_short='1/2/2',
group_address_position='1/2/3',
group_address_position_state='1/2/4')
self.loop.run_until_complete(asyncio.Task(cover.stop()))
self.assertEqual(xknx.telegrams.qsize(), 1)
telegram = xknx.telegrams.get_nowait()
self.assertEqual(telegram,
Telegram(GroupAddress('1/2/2'), payload=DPTBinary(0)))
def test_sync(self):
"""Test sync function / sending group reads to KNX bus."""
xknx = XKNX(loop=self.loop)
cover = Cover(
xknx,
'TestCover',
group_address_long='1/2/1',
group_address_short='1/2/2',
group_address_position_state='1/2/3')
self.loop.run_until_complete(asyncio.Task(cover.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_sync_angle_state(self):
"""Test sync function with angle/explicit state."""
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')
self.loop.run_until_complete(asyncio.Task(cover.sync(False)))
self.assertEqual(xknx.telegrams.qsize(), 1)
telegram1 = xknx.telegrams.get_nowait()
self.assertEqual(telegram1,
Telegram(GroupAddress('1/2/4'), TelegramType.GROUP_READ))
def test_position_without_position_address_down(self):
"""Test moving cover down - with no absolute positioning supported."""
xknx = XKNX(loop=self.loop)
cover = Cover(
xknx,
'TestCover',
group_address_long='1/2/1',
group_address_short='1/2/2',
group_address_position_state='1/2/4')
cover.travelcalculator.set_position(70)
self.loop.run_until_complete(asyncio.Task(cover.set_position(80)))
self.assertEqual(xknx.telegrams.qsize(), 1)
telegram = xknx.telegrams.get_nowait()
self.assertEqual(telegram,
Telegram(GroupAddress('1/2/1'), payload=DPTBinary(0)))
def parse_group_cover(self, entries):
"""Parse a cover section of xknx.yaml."""
for entry in entries:
cover = Cover.from_config(
self.xknx,
entry,
entries[entry])
self.xknx.devices.add(cover)
def test_angle(self):
"""Test changing angle."""
xknx = XKNX(loop=self.loop)
cover = Cover(
xknx,
'Children.Venetian',
group_address_long='1/4/14',
group_address_short='1/4/15',
group_address_position_state='1/4/17',
group_address_position='1/4/16',
group_address_angle='1/4/18',
group_address_angle_state='1/4/19')
self.loop.run_until_complete(asyncio.Task(cover.set_angle(50)))
self.assertEqual(xknx.telegrams.qsize(), 1)
telegram = xknx.telegrams.get_nowait()
self.assertEqual(telegram,
Telegram(GroupAddress('1/4/18'), payload=DPTArray(0x80)))
def test_state_addresses_while_travelling(self):
"""Test state addresses of cover while travelling."""
xknx = XKNX(loop=self.loop)
cover = Cover(
xknx,
'TestCover',
group_address_long='1/2/1',
group_address_short='1/2/2',
group_address_position='1/2/3',
group_address_position_state='1/2/4',
group_address_angle='1/2/5',
group_address_angle_state='1/2/6')
with patch('time.time') as mock_time:
mock_time.return_value = 1517000000.0
self.loop.run_until_complete(asyncio.Task(cover.set_up()))
mock_time.return_value = 1517000001.0
self.assertEqual(cover.state_addresses(), [])
def test_has_group_address(self):
"""Test sensor has group address."""
xknx = XKNX(loop=self.loop)
cover = Cover(
xknx,
'TestCover',
group_address_long='1/2/1',
group_address_short='1/2/2',
group_address_position='1/2/3',
group_address_position_state='1/2/4',
group_address_angle='1/2/5',
group_address_angle_state='1/2/6')
self.assertTrue(cover.has_group_address(GroupAddress('1/2/1')))
self.assertTrue(cover.has_group_address(GroupAddress('1/2/2')))
self.assertTrue(cover.has_group_address(GroupAddress('1/2/3')))
self.assertTrue(cover.has_group_address(GroupAddress('1/2/4')))
self.assertTrue(cover.has_group_address(GroupAddress('1/2/5')))
self.assertTrue(cover.has_group_address(GroupAddress('1/2/6')))
self.assertFalse(cover.has_group_address(GroupAddress('1/2/7')))
def test_do(self):
"""Test 'do' functionality."""
async def async_none():
return None
xknx = XKNX(loop=self.loop)
cover = Cover(
xknx,
'TestCover')
with patch('xknx.devices.Cover.set_up') as mock:
mock.return_value = asyncio.ensure_future(async_none())
self.loop.run_until_complete(asyncio.Task(cover.do("up")))
mock.assert_called_once_with()
with patch('xknx.devices.Cover.set_short_up') as mock:
mock.return_value = asyncio.ensure_future(async_none())
self.loop.run_until_complete(asyncio.Task(cover.do("short_up")))
mock.assert_called_once_with()
with patch('xknx.devices.Cover.set_down') as mock:
mock.return_value = asyncio.ensure_future(async_none())
self.loop.run_until_complete(asyncio.Task(cover.do("down")))
mock.assert_called_once_with()
with patch('xknx.devices.Cover.set_short_down') as mock:
mock.return_value = asyncio.ensure_future(async_none())
self.loop.run_until_complete(asyncio.Task(cover.do("short_down")))
mock.assert_called_once_with()
with patch('xknx.devices.Cover.stop') as mock:
mock.return_value = asyncio.ensure_future(async_none())
self.loop.run_until_complete(asyncio.Task(cover.do("stop")))
mock.assert_called_once_with()
def test_process_callback(self):
"""Test process / reading telegrams from telegram queue. Test if callback is executed."""
# pylint: disable=no-self-use
xknx = XKNX(loop=self.loop)
cover = Cover(
xknx,
'TestCover',
group_address_long='1/2/1',
group_address_short='1/2/2',
group_address_position='1/2/3',
group_address_position_state='1/2/4')
after_update_callback = Mock()
async def async_after_update_callback(device):
"""Async callback."""
after_update_callback(device)
cover.register_device_updated_cb(async_after_update_callback)
telegram = Telegram(GroupAddress('1/2/4'), payload=DPTArray(42))
self.loop.run_until_complete(asyncio.Task(cover.process(telegram)))
after_update_callback.assert_called_with(cover)
def test_position_without_position_address_uninitialized_down(self):
"""Test moving uninitialized cover to absolute position - with no absolute positioning supported."""
xknx = XKNX(loop=self.loop)
cover = Cover(
xknx,
"TestCover",
group_address_long="1/2/1",
group_address_short="1/2/2",
group_address_position_state="1/2/4",
)
with patch("logging.Logger.warning") as mock_warn:
self.loop.run_until_complete(cover.set_position(50))
self.assertEqual(xknx.telegrams.qsize(), 0)
mock_warn.assert_called_with(
"Current position unknown. Initialize cover by moving to end position."
)
self.loop.run_until_complete(cover.set_position(100))
print(cover.travelcalculator.position_closed)
self.assertEqual(xknx.telegrams.qsize(), 1)
telegram = xknx.telegrams.get_nowait()
self.assertEqual(telegram,
Telegram(GroupAddress("1/2/1"), payload=DPTBinary(1)))
async def test_sync(self):
"""Test sync function / sending group reads to KNX bus."""
xknx = XKNX()
cover = Cover(
xknx,
"TestCover",
group_address_long="1/2/1",
group_address_short="1/2/2",
group_address_position_state="1/2/3",
)
await cover.sync()
assert xknx.telegrams.qsize() == 1
telegram1 = xknx.telegrams.get_nowait()
assert telegram1 == Telegram(destination_address=GroupAddress("1/2/3"),
payload=GroupValueRead())
def test_config_cover_venetian_with_inverted_position(self):
"""Test reading Cover with angle from config file with inverted position/angle."""
self.assertEqual(
TestConfig.xknx.devices['Children.Venetian2'],
Cover(TestConfig.xknx,
'Children.Venetian2',
group_address_long='1/4/14',
group_address_short='1/4/15',
group_address_position_state='1/4/17',
group_address_position='1/4/16',
group_address_angle='1/4/18',
group_address_angle_state='1/4/19',
invert_position=True,
invert_angle=True,
device_updated_cb=TestConfig.xknx.devices.device_updated))
def test_process_callback(self):
"""Test process / reading telegrams from telegram queue. Test if callback is executed."""
# pylint: disable=no-self-use
xknx = XKNX(loop=self.loop)
cover = Cover(xknx,
'TestCover',
group_address_long='1/2/1',
group_address_short='1/2/2',
group_address_position='1/2/3',
group_address_position_state='1/2/4')
after_update_callback = Mock()
@asyncio.coroutine
def async_after_update_callback(device):
"""Async callback."""
after_update_callback(device)
cover.register_device_updated_cb(async_after_update_callback)
telegram = Telegram(Address('1/2/4'), payload=DPTArray(42))
self.loop.run_until_complete(asyncio.Task(cover.process(telegram)))
after_update_callback.assert_called_with(cover)
def test_config_cover_venetian(self):
"""Test reading Cover with angle from config file."""
self.assertEqual(
TestConfig.xknx.devices["Children.Venetian"],
Cover(
TestConfig.xknx,
"Children.Venetian",
group_address_long="1/4/14",
group_address_short="1/4/15",
group_address_position_state="1/4/17",
group_address_position="1/4/16",
group_address_angle="1/4/18",
group_address_angle_state="1/4/19",
),
)
def test_config_cover(self):
"""Test reading Cover from config file."""
self.assertEqual(
TestConfig.xknx.devices["Livingroom.Shutter_2"],
Cover(
TestConfig.xknx,
"Livingroom.Shutter_2",
group_address_long="1/4/5",
group_address_short="1/4/6",
group_address_position_state="1/4/7",
group_address_position="1/4/8",
travel_time_down=50,
travel_time_up=60,
),
)
def test_config_cover_device_class(self):
"""Test reading cover with device_class from config file."""
self.assertEqual(
TestConfig.xknx.devices["Livingroom.Shutter_3"],
Cover(
TestConfig.xknx,
"Livingroom.Shutter_3",
group_address_long="1/4/9",
group_address_short="1/4/10",
group_address_position_state="1/4/11",
travel_time_down=50,
travel_time_up=60,
device_class="shutter",
),
)
async def test_sync_angle_state(self):
"""Test sync function with angle/explicit state."""
xknx = XKNX()
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",
)
await cover.sync()
assert xknx.telegrams.qsize() == 1
telegram1 = xknx.telegrams.get_nowait()
assert telegram1 == Telegram(destination_address=GroupAddress("1/2/4"),
payload=GroupValueRead())
async def test_supports_stop_false(self):
"""Test support_position_true."""
xknx = XKNX()
cover = Cover(
xknx,
"Children.Venetian",
group_address_long="1/4/14",
group_address_position="1/4/16",
group_address_angle="1/4/18",
)
assert not cover.supports_stop
with patch("logging.Logger.warning") as mock_warn:
await cover.stop()
assert xknx.telegrams.qsize() == 0
mock_warn.assert_called_with("Stop not supported for device %s",
"Children.Venetian")
def test_process_callback(self):
"""Test process / reading telegrams from telegram queue. Test if callback is executed."""
# pylint: disable=no-self-use
xknx = XKNX()
cover = Cover(
xknx,
"TestCover",
group_address_long="1/2/1",
group_address_short="1/2/2",
group_address_stop="1/2/3",
group_address_position="1/2/4",
group_address_position_state="1/2/5",
group_address_angle="1/2/6",
group_address_angle_state="1/2/7",
)
after_update_callback = Mock()
async def async_after_update_callback(device):
"""Async callback."""
after_update_callback(device)
cover.register_device_updated_cb(async_after_update_callback)
for address, payload, feature in [
("1/2/1", DPTBinary(1), "long"),
("1/2/2", DPTBinary(1), "short"),
("1/2/4", DPTArray(42), "position"),
("1/2/5", DPTArray(42), "position state"),
("1/2/6", DPTArray(42), "angle"),
("1/2/7", DPTArray(51), "angle state"),
]:
with self.subTest(address=address, feature=feature):
telegram = Telegram(GroupAddress(address), payload=payload)
self.loop.run_until_complete(cover.process(telegram))
after_update_callback.assert_called_with(cover)
after_update_callback.reset_mock()
# Stop only when cover is travelling
telegram = Telegram(GroupAddress("1/2/3"), payload=DPTBinary(1))
self.loop.run_until_complete(cover.process(telegram))
after_update_callback.assert_not_called()
self.loop.run_until_complete(cover.set_down())
self.loop.run_until_complete(cover.process(telegram))
after_update_callback.assert_called_with(cover)
async def test_set_short_down(self):
"""Test moving cover to 'down' position."""
xknx = XKNX()
cover = Cover(
xknx,
"TestCoverShortDown",
group_address_long="1/2/1",
group_address_short="1/2/2",
group_address_position="1/2/3",
group_address_position_state="1/2/4",
)
await cover.set_down()
assert xknx.telegrams.qsize() == 1
telegram = xknx.telegrams.get_nowait()
assert telegram == Telegram(
destination_address=GroupAddress("1/2/1"),
payload=GroupValueWrite(DPTBinary(1)),
)
async def test_position(self):
"""Test moving cover to absolute position."""
xknx = XKNX()
cover = Cover(
xknx,
"TestCover",
group_address_long="1/2/1",
group_address_short="1/2/2",
group_address_position="1/2/3",
group_address_position_state="1/2/4",
)
await cover.set_position(50)
assert xknx.telegrams.qsize() == 1
telegram = xknx.telegrams.get_nowait()
assert telegram == Telegram(
destination_address=GroupAddress("1/2/3"),
payload=GroupValueWrite(DPTArray(0x80)),
)
def test_cover(self):
"""Test string representation of cover object."""
xknx = XKNX(loop=self.loop)
cover = Cover(xknx,
name='Rolladen',
group_address_long='1/2/3',
group_address_short='1/2/4',
group_address_position='1/2/5',
group_address_position_state='1/2/6',
group_address_angle='1/2/7',
group_address_angle_state='1/2/8',
travel_time_down=8,
travel_time_up=10)
self.assertEqual(
str(cover),
'<Cover name="Rolladen" updown="GroupAddress("1/2/3")/None/None/None" step="GroupAddress("1/2/4")/None/None/None" position="Group'
'Address("1/2/5")/GroupAddress("1/2/6")/None/None" angle="GroupAddress("1/2/7")/GroupAddress("1/2/8")/None/None" travel_time_down="8'
'" travel_time_up="10" />')
async def test_set_short_up(self):
"""Test moving cover 'short up'."""
xknx = XKNX()
cover = Cover(
xknx,
"TestCover",
group_address_long="1/2/1",
group_address_short="1/2/2",
group_address_position="1/2/3",
group_address_position_state="1/2/4",
)
await cover.set_short_up()
assert xknx.telegrams.qsize() == 1
telegram = xknx.telegrams.get_nowait()
# DPT 1.008 - 0:up 1:down
assert telegram == Telegram(
destination_address=GroupAddress("1/2/2"),
payload=GroupValueWrite(DPTBinary(0)),
)
async def test_angle(self):
"""Test changing angle."""
xknx = XKNX()
cover = Cover(
xknx,
"Children.Venetian",
group_address_long="1/4/14",
group_address_short="1/4/15",
group_address_position_state="1/4/17",
group_address_position="1/4/16",
group_address_angle="1/4/18",
group_address_angle_state="1/4/19",
)
await cover.set_angle(50)
assert xknx.telegrams.qsize() == 1
telegram = xknx.telegrams.get_nowait()
assert telegram == Telegram(
destination_address=GroupAddress("1/4/18"),
payload=GroupValueWrite(DPTArray(0x80)),
)
def test_process_stop(self):
"""Test process / reading telegrams from telegram queue. Test if stop is processed correctly."""
xknx = XKNX(loop=self.loop)
cover = Cover(
xknx,
'TestCover',
group_address_long='1/2/1',
group_address_stop='1/2/2',
)
cover.travelcalculator.set_position(50)
self.loop.run_until_complete(asyncio.Task(cover.set_down()))
self.assertTrue(cover.is_traveling())
telegram = Telegram(GroupAddress('1/2/2'), payload=DPTBinary(1))
self.loop.run_until_complete(asyncio.Task(cover.process(telegram)))
self.assertFalse(cover.is_traveling())
def test_process_short_stop(self):
"""Test process / reading telegrams from telegram queue. Test if stop is processed correctly."""
xknx = XKNX()
cover = Cover(
xknx,
"TestCover",
group_address_long="1/2/1",
group_address_short="1/2/2",
)
cover.travelcalculator.set_position(50)
self.loop.run_until_complete(cover.set_down())
self.assertTrue(cover.is_traveling())
telegram = Telegram(GroupAddress("1/2/2"), payload=DPTBinary(1))
self.loop.run_until_complete(cover.process(telegram))
self.assertFalse(cover.is_traveling())
def test_cover(self):
"""Test string representation of cover object."""
xknx = XKNX()
cover = Cover(
xknx,
name="Rolladen",
group_address_long="1/2/2",
group_address_short="1/2/3",
group_address_stop="1/2/4",
group_address_position="1/2/5",
group_address_position_state="1/2/6",
group_address_angle="1/2/7",
group_address_angle_state="1/2/8",
travel_time_down=8,
travel_time_up=10,
)
self.assertEqual(
str(cover),
'<Cover name="Rolladen" updown="GroupAddress("1/2/2")/None/None/None" step="GroupAddress("1/2/3")/None/None/None" '
'stop="GroupAddress("1/2/4")/None/None/None" position="GroupAddress("1/2/5")/GroupAddress("1/2/6")/None/None" '
'angle="GroupAddress("1/2/7")/GroupAddress("1/2/8")/None/None" '
'travel_time_down="8" travel_time_up="10" />',
)
async def test_auto_stop(self, time_travel):
"""Test auto stop functionality."""
xknx = XKNX()
cover = Cover(
xknx,
"TestCoverAutoStop",
group_address_long="1/2/1",
group_address_stop="1/2/2",
travel_time_down=10,
travel_time_up=10,
)
with patch("time.time") as mock_time:
mock_time.return_value = 1517000000.0
# we start with state 0 - open covers (up) this is assumed immediately
await cover.set_position(0)
assert xknx.telegrams.qsize() == 1
_ = xknx.telegrams.get_nowait()
await cover.set_position(50)
await time_travel(1)
mock_time.return_value = 1517000001.0
assert xknx.telegrams.qsize() == 1
telegram1 = xknx.telegrams.get_nowait()
assert telegram1 == Telegram(
destination_address=GroupAddress("1/2/1"),
payload=GroupValueWrite(DPTBinary(True)),
)
await time_travel(4)
mock_time.return_value = 1517000005.0
assert xknx.telegrams.qsize() == 1
telegram1 = xknx.telegrams.get_nowait()
assert telegram1 == Telegram(
destination_address=GroupAddress("1/2/2"),
payload=GroupValueWrite(DPTBinary(True)),
)
def test_has_group_address(self):
"""Test sensor has group address."""
xknx = XKNX(loop=self.loop)
cover = Cover(xknx,
'TestCover',
group_address_long='1/2/1',
group_address_short='1/2/2',
group_address_position='1/2/3',
group_address_position_state='1/2/4',
group_address_angle='1/2/5',
group_address_angle_state='1/2/6')
self.assertTrue(cover.has_group_address(GroupAddress('1/2/1')))
self.assertTrue(cover.has_group_address(GroupAddress('1/2/2')))
self.assertTrue(cover.has_group_address(GroupAddress('1/2/3')))
self.assertTrue(cover.has_group_address(GroupAddress('1/2/4')))
self.assertTrue(cover.has_group_address(GroupAddress('1/2/5')))
self.assertTrue(cover.has_group_address(GroupAddress('1/2/6')))
self.assertFalse(cover.has_group_address(GroupAddress('1/2/7')))
def test_stop(self):
"""Test stopping cover."""
xknx = XKNX()
cover_short_stop = Cover(
xknx,
"TestCover",
group_address_long="1/2/1",
group_address_short="1/2/2",
group_address_position="1/2/3",
group_address_position_state="1/2/4",
)
self.loop.run_until_complete(cover_short_stop.stop())
self.assertEqual(xknx.telegrams.qsize(), 1)
telegram = xknx.telegrams.get_nowait()
self.assertEqual(
telegram,
Telegram(
destination_address=GroupAddress("1/2/2"),
payload=GroupValueWrite(DPTBinary(1)),
),
)
cover_manual_stop = Cover(
xknx,
"TestCover",
group_address_long="1/2/1",
group_address_short="1/2/2",
group_address_stop="1/2/0",
group_address_position="1/2/3",
group_address_position_state="1/2/4",
)
self.loop.run_until_complete(cover_manual_stop.stop())
self.assertEqual(xknx.telegrams.qsize(), 1)
telegram = xknx.telegrams.get_nowait()
self.assertEqual(
telegram,
Telegram(
destination_address=GroupAddress("1/2/0"),
payload=GroupValueWrite(DPTBinary(1)),
),
)
def test_has_group_address(self):
"""Test sensor has group address."""
xknx = XKNX()
cover = Cover(
xknx,
"TestCover",
group_address_long="1/2/1",
group_address_short="1/2/2",
group_address_position="1/2/3",
group_address_position_state="1/2/4",
group_address_angle="1/2/5",
group_address_angle_state="1/2/6",
)
assert cover.has_group_address(GroupAddress("1/2/1"))
assert cover.has_group_address(GroupAddress("1/2/2"))
assert cover.has_group_address(GroupAddress("1/2/3"))
assert cover.has_group_address(GroupAddress("1/2/4"))
assert cover.has_group_address(GroupAddress("1/2/5"))
assert cover.has_group_address(GroupAddress("1/2/6"))
assert not cover.has_group_address(GroupAddress("1/2/7"))
async def test_is_traveling(self):
"""Test moving cover to absolute position."""
xknx = XKNX()
cover = Cover(
xknx,
"TestCover",
group_address_long="1/2/1",
group_address_stop="1/2/2",
group_address_position="1/2/3",
group_address_position_state="1/2/4",
travel_time_down=10,
travel_time_up=10,
)
with patch("time.time") as mock_time:
mock_time.return_value = 1517000000.0
assert not cover.is_traveling()
assert not cover.is_opening()
assert not cover.is_closing()
assert cover.position_reached()
# we start with state open covers (up)
cover.travelcalculator.set_position(0)
await cover.set_down()
assert cover.is_traveling()
assert cover.is_open()
assert not cover.is_closed()
assert not cover.is_opening()
assert cover.is_closing()
mock_time.return_value = 1517000005.0 # 5 Seconds, half way
assert not cover.position_reached()
assert cover.is_traveling()
assert not cover.is_open()
assert not cover.is_closed()
assert not cover.is_opening()
assert cover.is_closing()
mock_time.return_value = 1517000010.0 # 10 Seconds, fully closed
assert cover.position_reached()
assert not cover.is_traveling()
assert not cover.is_open()
assert cover.is_closed()
assert not cover.is_opening()
assert not cover.is_closing()
# up again
await cover.set_up()
assert not cover.position_reached()
assert cover.is_traveling()
assert not cover.is_open()
assert cover.is_closed()
assert cover.is_opening()
assert not cover.is_closing()
mock_time.return_value = 1517000015.0 # 15 Seconds, half way
assert not cover.position_reached()
assert cover.is_traveling()
assert not cover.is_open()
assert not cover.is_closed()
assert cover.is_opening()
assert not cover.is_closing()
mock_time.return_value = 1517000016.0 # 16 Seconds, manual stop
await cover.stop()
assert cover.position_reached()
assert not cover.is_traveling()
assert not cover.is_open()
assert not cover.is_closed()
assert not cover.is_opening()
assert not cover.is_closing()
def test_is_traveling(self):
"""Test moving cover to absolute position."""
xknx = XKNX(loop=self.loop)
cover = Cover(
xknx,
"TestCover",
group_address_long="1/2/1",
group_address_stop="1/2/2",
group_address_position="1/2/3",
group_address_position_state="1/2/4",
travel_time_down=10,
travel_time_up=10,
)
with patch("time.time") as mock_time:
mock_time.return_value = 1517000000.0
self.assertFalse(cover.is_traveling())
self.assertFalse(cover.is_opening())
self.assertFalse(cover.is_closing())
self.assertTrue(cover.position_reached())
# we start with state open covers (up)
cover.travelcalculator.set_position(0)
self.loop.run_until_complete(cover.set_down())
self.assertTrue(cover.is_traveling())
self.assertTrue(cover.is_open())
self.assertFalse(cover.is_closed())
self.assertFalse(cover.is_opening())
self.assertTrue(cover.is_closing())
mock_time.return_value = 1517000005.0 # 5 Seconds, half way
self.assertFalse(cover.position_reached())
self.assertTrue(cover.is_traveling())
self.assertFalse(cover.is_open())
self.assertFalse(cover.is_closed())
self.assertFalse(cover.is_opening())
self.assertTrue(cover.is_closing())
mock_time.return_value = 1517000010.0 # 10 Seconds, fully closed
self.assertTrue(cover.position_reached())
self.assertFalse(cover.is_traveling())
self.assertFalse(cover.is_open())
self.assertTrue(cover.is_closed())
self.assertFalse(cover.is_opening())
self.assertFalse(cover.is_closing())
# up again
self.loop.run_until_complete(cover.set_up())
self.assertFalse(cover.position_reached())
self.assertTrue(cover.is_traveling())
self.assertFalse(cover.is_open())
self.assertTrue(cover.is_closed())
self.assertTrue(cover.is_opening())
self.assertFalse(cover.is_closing())
mock_time.return_value = 1517000015.0 # 15 Seconds, half way
self.assertFalse(cover.position_reached())
self.assertTrue(cover.is_traveling())
self.assertFalse(cover.is_open())
self.assertFalse(cover.is_closed())
self.assertTrue(cover.is_opening())
self.assertFalse(cover.is_closing())
mock_time.return_value = 1517000016.0 # 16 Seconds, manual stop
self.loop.run_until_complete(cover.stop())
self.assertTrue(cover.position_reached())
self.assertFalse(cover.is_traveling())
self.assertFalse(cover.is_open())
self.assertFalse(cover.is_closed())
self.assertFalse(cover.is_opening())
self.assertFalse(cover.is_closing())
async def test_stop(self):
"""Test stopping cover."""
xknx = XKNX()
cover_short_stop = Cover(
xknx,
"TestCover",
group_address_long="1/2/1",
group_address_short="1/2/2",
group_address_position="1/2/3",
group_address_position_state="1/2/4",
)
# Attempt stopping while not actually moving
await cover_short_stop.stop()
assert xknx.telegrams.qsize() == 0
# Attempt stopping while moving down
cover_short_stop.travelcalculator.set_position(0)
await cover_short_stop.set_down()
await cover_short_stop.stop()
assert xknx.telegrams.qsize() == 2
telegram = xknx.telegrams.get_nowait()
assert telegram == Telegram(
destination_address=GroupAddress("1/2/1"),
payload=GroupValueWrite(DPTBinary(1)),
)
telegram = xknx.telegrams.get_nowait()
assert telegram == Telegram(
destination_address=GroupAddress("1/2/2"),
payload=GroupValueWrite(DPTBinary(1)),
)
# Attempt stopping while moving up
cover_short_stop.travelcalculator.set_position(100)
await cover_short_stop.set_up()
await cover_short_stop.stop()
assert xknx.telegrams.qsize() == 2
telegram = xknx.telegrams.get_nowait()
assert telegram == Telegram(
destination_address=GroupAddress("1/2/1"),
payload=GroupValueWrite(DPTBinary(0)),
)
telegram = xknx.telegrams.get_nowait()
assert telegram == Telegram(
destination_address=GroupAddress("1/2/2"),
payload=GroupValueWrite(DPTBinary(0)),
)
cover_manual_stop = Cover(
xknx,
"TestCover",
group_address_long="1/2/1",
group_address_short="1/2/2",
group_address_stop="1/2/0",
group_address_position="1/2/3",
group_address_position_state="1/2/4",
)
await cover_manual_stop.stop()
assert xknx.telegrams.qsize() == 1
telegram = xknx.telegrams.get_nowait()
assert telegram == Telegram(
destination_address=GroupAddress("1/2/0"),
payload=GroupValueWrite(DPTBinary(1)),
)
def test_process_position(self):
"""Test process / reading telegrams from telegram queue. Test if position is processed correctly."""
xknx = XKNX()
cover = Cover(
xknx,
"TestCover",
group_address_long="1/2/1",
group_address_short="1/2/2",
group_address_position="1/2/3",
group_address_position_state="1/2/4",
)
# initial position process - position is unknown so this is the new state - not moving
telegram = Telegram(GroupAddress("1/2/3"), payload=DPTArray(213))
self.loop.run_until_complete(cover.process(telegram))
self.assertEqual(cover.current_position(), 84)
self.assertFalse(cover.is_traveling())
# state telegram updates current position - we are not moving so this is new state - not moving
telegram = Telegram(GroupAddress("1/2/4"), payload=DPTArray(42))
self.loop.run_until_complete(cover.process(telegram))
self.assertEqual(cover.current_position(), 16)
self.assertFalse(cover.is_traveling())
self.assertEqual(cover.travelcalculator.travel_to_position, 16)
# new position - movement starts
telegram = Telegram(GroupAddress("1/2/3"), payload=DPTArray(255))
self.loop.run_until_complete(cover.process(telegram))
self.assertEqual(cover.current_position(), 16)
self.assertTrue(cover.is_closing())
self.assertEqual(cover.travelcalculator.travel_to_position, 100)
# new state while moving - movement goes on; travelcalculator updated
telegram = Telegram(GroupAddress("1/2/4"), payload=DPTArray(213))
self.loop.run_until_complete(cover.process(telegram))
self.assertEqual(cover.current_position(), 84)
self.assertTrue(cover.is_closing())
self.assertEqual(cover.travelcalculator.travel_to_position, 100)
def test_is_traveling(self):
"""Test moving cover to absolute position."""
xknx = XKNX(loop=self.loop)
cover = Cover(xknx,
'TestCover',
group_address_long='1/2/1',
group_address_position='1/2/3',
group_address_position_state='1/2/4',
travel_time_down=10,
travel_time_up=10)
with patch('time.time') as mock_time:
mock_time.return_value = 1517000000.0
self.assertFalse(cover.is_traveling())
self.assertTrue(cover.position_reached())
self.loop.run_until_complete(asyncio.Task(cover.set_up()))
self.assertTrue(cover.is_traveling())
self.assertFalse(cover.is_open())
self.assertTrue(cover.is_closed())
mock_time.return_value = 1517000005.0 # 5 Seconds, half way
self.assertFalse(cover.position_reached())
self.assertTrue(cover.is_traveling())
self.assertFalse(cover.is_open())
self.assertFalse(cover.is_closed())
mock_time.return_value = 1517000010.0 # 10 Seconds, fully open
self.assertTrue(cover.position_reached())
self.assertFalse(cover.is_traveling())
self.assertTrue(cover.is_open())
self.assertFalse(cover.is_closed())
def parse_group_cover(self, entries):
"""Parse a cover section of xknx.yaml."""
for entry in entries:
cover = Cover.from_config(self.xknx, entry, entries[entry])
self.xknx.devices.add(cover)
def test_is_traveling(self):
"""Test moving cover to absolute position."""
xknx = XKNX(loop=self.loop)
cover = Cover(
xknx,
'TestCover',
group_address_long='1/2/1',
group_address_position='1/2/3',
group_address_position_state='1/2/4',
travel_time_down=10,
travel_time_up=10)
with patch('time.time') as mock_time:
mock_time.return_value = 1517000000.0
self.assertFalse(cover.is_traveling())
self.assertTrue(cover.position_reached())
self.loop.run_until_complete(asyncio.Task(cover.set_up()))
self.assertTrue(cover.is_traveling())
self.assertFalse(cover.is_open())
self.assertTrue(cover.is_closed())
mock_time.return_value = 1517000005.0 # 5 Seconds, half way
self.assertFalse(cover.position_reached())
self.assertTrue(cover.is_traveling())
self.assertFalse(cover.is_open())
self.assertFalse(cover.is_closed())
mock_time.return_value = 1517000010.0 # 10 Seconds, fully open
self.assertTrue(cover.position_reached())
self.assertFalse(cover.is_traveling())
self.assertTrue(cover.is_open())
self.assertFalse(cover.is_closed())
