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)
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_process_callback(self): """Test after_update_callback after state of switch was changed.""" # pylint: disable=protected-access xknx = XKNX() switch = BinarySensor(xknx, "TestInput", group_address_state="1/2/3", ignore_internal_state=False) 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)), ) self.loop.run_until_complete(switch.process(telegram)) # no _context_task started because ignore_internal_state is False self.assertIsNone(switch._context_task) async_after_update_callback.assert_called_once_with(switch) async_after_update_callback.reset_mock() # send same telegram again self.loop.run_until_complete(switch.process(telegram)) async_after_update_callback.assert_not_called()
def test_process_callback_ignore_internal_state_no_counter(self): """Test after_update_callback after state of switch was changed.""" # pylint: disable=protected-access xknx = XKNX() switch = BinarySensor( xknx, "TestInput", group_address_state="1/2/3", ignore_internal_state=True, context_timeout=0, ) 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(group_address=GroupAddress("1/2/3"), payload=DPTBinary(1)) self.loop.run_until_complete(switch.process(telegram)) # no _context_task started because context_timeout is False self.assertIsNone(switch._context_task) after_update_callback.assert_called_once_with(switch) after_update_callback.reset_mock() # send same telegram again self.loop.run_until_complete(switch.process(telegram)) after_update_callback.assert_called_once_with(switch)
def test_process_group_value_response(self): """Test precess of GroupValueResponse telegrams.""" # pylint: disable=protected-access 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(group_address=GroupAddress("1/2/3"), payload=DPTBinary(1)) response_telegram = Telegram( group_address=GroupAddress("1/2/3"), payload=DPTBinary(1), telegramtype=TelegramType.GROUP_RESPONSE, ) self.assertIsNone(switch.state) # initial GroupValueResponse changes state and runs callback self.loop.run_until_complete(switch.process(response_telegram)) self.assertTrue(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() self.loop.run_until_complete(switch.process(write_telegram)) self.assertTrue(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() self.loop.run_until_complete(switch.process(response_telegram)) async_after_update_callback.assert_not_called()
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_ignore_internal_state(self): """Test after_update_callback after state of switch was changed.""" # pylint: disable=protected-access xknx = XKNX() switch = BinarySensor( xknx, "TestInput", group_address_state="1/2/3", ignore_internal_state=True, context_timeout=0.001, ) 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(group_address=GroupAddress("1/2/3"), payload=DPTBinary(1)) self.assertEqual(switch.counter, 0) self.loop.run_until_complete(switch.process(telegram)) after_update_callback.assert_not_called() self.assertEqual(switch.counter, 1) self.loop.run_until_complete(switch._context_task) after_update_callback.assert_called_with(switch) # once with counter 1 and once with counter 0 self.assertEqual(after_update_callback.call_count, 2) after_update_callback.reset_mock() # send same telegram again self.loop.run_until_complete(switch.process(telegram)) self.assertEqual(switch.counter, 1) self.loop.run_until_complete(switch.process(telegram)) self.assertEqual(switch.counter, 2) after_update_callback.assert_not_called() self.loop.run_until_complete(switch._context_task) after_update_callback.assert_called_with(switch) # once with counter 2 and once with counter 0 self.assertEqual(after_update_callback.call_count, 2) self.assertEqual(switch.counter, 0)
async def test_process_callback_ignore_internal_state(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.001, ) 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)), ) assert switch.counter == 0 await switch.process(telegram) async_after_update_callback.assert_not_called() assert switch.counter == 1 await switch._context_task async_after_update_callback.assert_called_with(switch) # once with counter 1 and once with counter 0 assert async_after_update_callback.call_count == 2 async_after_update_callback.reset_mock() # send same telegram again await switch.process(telegram) assert switch.counter == 1 await switch.process(telegram) assert switch.counter == 2 async_after_update_callback.assert_not_called() await switch._context_task async_after_update_callback.assert_called_with(switch) # once with counter 2 and once with counter 0 assert async_after_update_callback.call_count == 2 assert switch.counter == 0