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)
async def test_position_without_position_address_down(self):
"""Test moving cover down - with no absolute positioning supported."""
xknx = XKNX()
cover = Cover(
xknx,
"TestCoverPWPAD",
group_address_long="1/2/1",
group_address_short="1/2/2",
group_address_position_state="1/2/4",
)
cover.travelcalculator.set_position(70)
await cover.set_position(80)
assert xknx.telegrams.qsize() == 1
telegram = xknx.telegrams.get_nowait()
assert telegram == Telegram(
destination_address=GroupAddress("1/2/1"),
payload=GroupValueWrite(DPTBinary(1)),
)
assert cover.travelcalculator._travel_to_position == 80
assert cover.is_closing()
# process the outgoing telegram to make sure it doesn't overwrite the target position
await cover.process(telegram)
assert cover.travelcalculator._travel_to_position == 80
await cover.stop() # clean up tasks
def test_position_without_position_address_down(self):
"""Test moving cover down - with no absolute positioning supported."""
xknx = XKNX()
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(cover.set_position(80))
self.assertEqual(xknx.telegrams.qsize(), 1)
telegram = xknx.telegrams.get_nowait()
self.assertEqual(
telegram,
Telegram(
destination_address=GroupAddress("1/2/1"),
payload=GroupValueWrite(DPTBinary(1)),
),
)
self.assertEqual(cover.travelcalculator.travel_to_position, 80)
self.assertTrue(cover.is_closing())
# process the outgoing telegram to make sure it doesn't overwrite the target position
self.loop.run_until_complete(cover.process(telegram))
self.assertEqual(cover.travelcalculator.travel_to_position, 80)
def test_process_down(self):
"""Test process / reading telegrams from telegram queue. Test if up/down 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.assertFalse(cover.is_traveling())
telegram = Telegram(GroupAddress("1/2/1"), payload=DPTBinary(1))
self.loop.run_until_complete(cover.process(telegram))
self.assertTrue(cover.is_closing())
async def test_process_position(self):
"""Test process / reading telegrams from telegram queue. Test if position is processed correctly."""
xknx = XKNX()
cover = Cover(
xknx,
"TestCoverProcessPosition",
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=GroupValueWrite(DPTArray(213)))
await cover.process(telegram)
assert cover.current_position() == 84
assert not 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=GroupValueWrite(DPTArray(42)))
await cover.process(telegram)
assert cover.current_position() == 16
assert not cover.is_traveling()
assert cover.travelcalculator._travel_to_position == 16
# new position - movement starts
telegram = Telegram(GroupAddress("1/2/3"),
payload=GroupValueWrite(DPTArray(255)))
await cover.process(telegram)
assert cover.current_position() == 16
assert cover.is_closing()
assert cover.travelcalculator._travel_to_position == 100
# new state while moving - movement goes on; travelcalculator updated
telegram = Telegram(GroupAddress("1/2/4"),
payload=GroupValueWrite(DPTArray(213)))
await cover.process(telegram)
assert cover.current_position() == 84
assert cover.is_closing()
assert cover.travelcalculator._travel_to_position == 100
await cover.stop() # clean up tasks
async def test_process_down(self):
"""Test process / reading telegrams from telegram queue. Test if up/down 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)
assert not cover.is_traveling()
telegram = Telegram(GroupAddress("1/2/1"),
payload=GroupValueWrite(DPTBinary(1)))
await cover.process(telegram)
assert cover.is_closing()
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(asyncio.Task(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(asyncio.Task(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(asyncio.Task(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())
