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())