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