Remove loop argument (#433)

* remove loop argument from XKNX()

use asyncio.get_running_loop() and asyncio.create_task()
(or non-async method in knxip_interface)

* test without loop argument

* Review: Fix date time tests. By the time you add the tasks to asyncio the loop is not yet running thus the error occurs.

Simply add the tasks to the created (but not yet started) loop and wait for it to run.

Co-authored-by: Marvin Wichmann <marvin.wichmann@unic.com>

home-assistant-plugin/custom_components/xknx/__init__.py

@@ -191,7 +191,6 @@ def init_xknx(self):
         """Initialize of KNX object."""
         self.xknx = XKNX(
             config=self.config_file(),
-            loop=self.hass.loop,
             own_address=self.config[DOMAIN][CONF_XKNX_INDIVIDUAL_ADDRESS],
             rate_limit=self.config[DOMAIN][CONF_XKNX_RATE_LIMIT],
             multicast_group=self.config[DOMAIN][CONF_XKNX_MCAST_GRP],

test/core_tests/config_test.py

@@ -42,7 +42,7 @@ def setUpClass(cls):
         )
         cls.datetime_patcher.start()
 
-        cls.xknx = XKNX(config="xknx.yaml", loop=cls.loop)
+        cls.xknx = XKNX(config="xknx.yaml")
 
     @classmethod
     def tearDownClass(cls):
@@ -553,7 +553,7 @@ def test_config_weather_expose_sensor(self):
     def test_config_file_not_found(self):
         """Test error message when reading a non exisiting config file."""
         with patch("logging.Logger.error") as mock_err:
-            XKNX(config="xknx_does_not_exist.yaml", loop=self.loop)
+            XKNX(config="xknx_does_not_exist.yaml")
             self.assertEqual(mock_err.call_count, 1)
 
     def test_config_file_error(self):
@@ -562,5 +562,5 @@ def test_config_file_error(self):
             "xknx.core.Config.parse_group_light"
         ) as mock_parse:
             mock_parse.side_effect = XKNXException()
-            XKNX(config="xknx.yaml", loop=self.loop)
+            XKNX(config="xknx.yaml")
             self.assertEqual(mock_err.call_count, 1)

test/core_tests/state_updater_test.py

@@ -26,7 +26,7 @@ def tearDown(self):
 
     def test_register_unregister(self):
         """Test register and unregister."""
-        xknx = XKNX(loop=self.loop)
+        xknx = XKNX()
         self.assertEqual(len(xknx.state_updater._workers), 0)
         # register when state address and sync_state is set
         remote_value_1 = RemoteValue(
@@ -54,7 +54,7 @@ def test_register_unregister(self):
 
     def test_tracker_parser(self):
         """Test parsing tracker options."""
-        xknx = XKNX(loop=self.loop)
+        xknx = XKNX()
 
         def _get_only_tracker() -> _StateTracker:
             # _workers is unordered so it just works with 1 item
@@ -104,7 +104,7 @@ def _get_only_tracker() -> _StateTracker:
     @patch("logging.Logger.warning")
     def test_tracker_parser_invalid_options(self, logging_warning_mock):
         """Test parsing invalid tracker options."""
-        xknx = XKNX(loop=self.loop)
+        xknx = XKNX()
 
         def _get_only_tracker() -> _StateTracker:
             # _workers is unordered so it just works with 1 item
@@ -152,7 +152,7 @@ def _get_only_tracker() -> _StateTracker:
 
     def test_state_updater_start_update_stop(self):
         """Test start, update_received and stop of StateUpdater."""
-        xknx = XKNX(loop=self.loop)
+        xknx = XKNX()
         remote_value_1 = RemoteValue(
             xknx, sync_state=True, group_address_state=GroupAddress("1/1/1")
         )

test/core_tests/telegram_queue_test.py

@@ -27,7 +27,7 @@ def tearDown(self):
     def test_start(self):
         """Test start, run and stop."""
         # pylint: disable=no-self-use
-        xknx = XKNX(loop=self.loop)
+        xknx = XKNX()
 
         telegram_in = Telegram(
             direction=TelegramDirection.INCOMING,
@@ -61,7 +61,7 @@ async def async_none():
 
         async_sleep_mock.return_value = asyncio.ensure_future(async_none())
 
-        xknx = XKNX(loop=self.loop)
+        xknx = XKNX()
         xknx.rate_limit = 20  # 50 ms per outgoing telegram
         sleep_time = 0.05  # 1 / 20
 
@@ -99,7 +99,7 @@ async def async_none():
     def test_register(self):
         """Test telegram_received_callback after state of switch was changed."""
         # pylint: disable=no-self-use
-        xknx = XKNX(loop=self.loop)
+        xknx = XKNX()
 
         telegram_received_callback = Mock()
 
@@ -125,7 +125,7 @@ async def async_telegram_received_cb(device):
     def test_unregister(self):
         """Test telegram_received_callback after state of switch was changed."""
         # pylint: disable=no-self-use
-        xknx = XKNX(loop=self.loop)
+        xknx = XKNX()
 
         telegram_received_callback = Mock()
 
@@ -155,7 +155,7 @@ async def async_telegram_received_cb(device):
     def test_process_to_device(self, devices_by_ga_mock):
         """Test process_telegram_incoming for forwarding telegram to a device."""
         # pylint: disable=no-self-use
-        xknx = XKNX(loop=self.loop)
+        xknx = XKNX()
 
         test_device = Mock()
         async_device_process = asyncio.Future()
@@ -180,7 +180,7 @@ def test_process_to_device(self, devices_by_ga_mock):
     def test_process_to_callback(self, devices_by_ga_mock):
         """Test process_telegram_incoming for returning after processing callback."""
         # pylint: disable=no-self-use
-        xknx = XKNX(loop=self.loop)
+        xknx = XKNX()
 
         telegram_received_callback = Mock()
 
@@ -207,7 +207,7 @@ async def async_telegram_received_cb(device):
     def test_outgoing(self, logger_warning_mock, if_mock):
         """Test outgoing telegrams in telegram queue."""
         # pylint: disable=no-self-use
-        xknx = XKNX(loop=self.loop)
+        xknx = XKNX()
 
         async_if_send_telegram = asyncio.Future()
         async_if_send_telegram.set_result(None)
@@ -238,7 +238,7 @@ def test_outgoing(self, logger_warning_mock, if_mock):
     def test_process_exception(self, process_tg_in_mock, logging_error_mock):
         """Test process_telegram exception handling."""
         # pylint: disable=no-self-use
-        xknx = XKNX(loop=self.loop)
+        xknx = XKNX()
 
         async def process_exception():
             raise CouldNotParseTelegram(
@@ -270,7 +270,7 @@ def test_process_all_telegrams(
     ):
         """Test _process_all_telegrams for clearing the queue."""
         # pylint: disable=no-self-use
-        xknx = XKNX(loop=self.loop)
+        xknx = XKNX()
 
         async_process_mock = asyncio.Future()
         async_process_mock.set_result(None)
@@ -302,7 +302,7 @@ def test_process_all_telegrams(
     def test_no_filters(self):
         """Test telegram_received_callback after state of switch was changed."""
         # pylint: disable=no-self-use
-        xknx = XKNX(loop=self.loop)
+        xknx = XKNX()
 
         telegram_received_callback = Mock()
 
@@ -328,7 +328,7 @@ async def async_telegram_received_cb(device):
     def test_positive_filters(self):
         """Test telegram_received_callback after state of switch was changed."""
         # pylint: disable=no-self-use
-        xknx = XKNX(loop=self.loop)
+        xknx = XKNX()
 
         telegram_received_callback = Mock()
 
@@ -357,7 +357,7 @@ async def async_telegram_received_cb(device):
     def test_negative_filters(self):
         """Test telegram_received_callback after state of switch was changed."""
         # pylint: disable=no-self-use
-        xknx = XKNX(loop=self.loop)
+        xknx = XKNX()
 
         telegram_received_callback = Mock()
 

test/core_tests/value_reader_test.py

@@ -24,7 +24,7 @@ def tearDown(self):
     @patch("xknx.core.ValueReader.timeout")
     def test_value_reader_read_success(self, timeout_mock):
         """Test value reader: successfull read."""
-        xknx = XKNX(loop=self.loop)
+        xknx = XKNX()
         test_group_address = GroupAddress("0/0/0")
         response_telegram = Telegram(
             group_address=test_group_address,
@@ -59,7 +59,7 @@ def test_value_reader_read_success(self, timeout_mock):
     @patch("logging.Logger.warning")
     def test_value_reader_read_timeout(self, logger_warning_mock):
         """Test value reader: read timeout."""
-        xknx = XKNX(loop=self.loop)
+        xknx = XKNX()
         value_reader = ValueReader(xknx, GroupAddress("0/0/0"), timeout_in_seconds=0)
 
         timed_out_read = self.loop.run_until_complete(value_reader.read())
@@ -85,7 +85,7 @@ def test_value_reader_read_timeout(self, logger_warning_mock):
 
     def test_value_reader_send_group_read(self):
         """Test value reader: send_group_read."""
-        xknx = XKNX(loop=self.loop)
+        xknx = XKNX()
         value_reader = ValueReader(xknx, GroupAddress("0/0/0"))
 
         self.loop.run_until_complete(value_reader.send_group_read())
@@ -101,7 +101,7 @@ def test_value_reader_send_group_read(self):
 
     def test_value_reader_telegram_received(self):
         """Test value reader: telegram_received."""
-        xknx = XKNX(loop=self.loop)
+        xknx = XKNX()
         test_group_address = GroupAddress("0/0/0")
         expected_telegram_1 = Telegram(
             group_address=test_group_address,

test/devices_tests/action_test.py

@@ -24,7 +24,7 @@ def tearDown(self):
     #
     def test_counter(self):
         """Test counter method."""
-        xknx = XKNX(loop=self.loop)
+        xknx = XKNX()
         action = ActionBase(xknx, counter=2)
         self.assertTrue(action.test_counter(None))
         self.assertFalse(action.test_counter(1))
@@ -33,7 +33,7 @@ def test_counter(self):
 
     def test_no_counter(self):
         """Test counter method with no counter set."""
-        xknx = XKNX(loop=self.loop)
+        xknx = XKNX()
         action = ActionBase(xknx, counter=None)
         self.assertTrue(action.test_counter(None))
         self.assertTrue(action.test_counter(1))
@@ -45,15 +45,15 @@ def test_no_counter(self):
     #
     def test_if_applicable_hook_on(self):
         """Test test_if_applicable method with hook set to 'on'."""
-        xknx = XKNX(loop=self.loop)
+        xknx = XKNX()
         action = ActionBase(xknx, counter=2, hook="on")
         self.assertTrue(action.test_if_applicable(True, 2))
         self.assertFalse(action.test_if_applicable(True, 3))
         self.assertFalse(action.test_if_applicable(False, 2))
 
     def test_if_applicable_hook_off(self):
         """Test test_if_applicable method with hook set to 'off'."""
-        xknx = XKNX(loop=self.loop)
+        xknx = XKNX()
         action = ActionBase(xknx, counter=2, hook="off")
         self.assertTrue(action.test_if_applicable(False, 2))
         self.assertFalse(action.test_if_applicable(False, 3))
@@ -64,15 +64,15 @@ def test_if_applicable_hook_off(self):
     #
     def test_execute_base_action(self):
         """Test if execute method of BaseAction shows correct info message."""
-        xknx = XKNX(loop=self.loop)
+        xknx = XKNX()
         action = ActionBase(xknx)
         with patch("logging.Logger.info") as mock_info:
             self.loop.run_until_complete(action.execute())
             mock_info.assert_called_with("Execute not implemented for %s", "ActionBase")
 
     def test_execute_action(self):
         """Test if execute method of Action calls correct do method of device."""
-        xknx = XKNX(loop=self.loop)
+        xknx = XKNX()
         light = Light(xknx, "Light1", group_address_switch="1/6/4")
         action = Action(xknx, target=light.name, method="on")
         with patch("xknx.devices.Light.do") as mock_do:
@@ -84,7 +84,7 @@ def test_execute_action(self):
 
     def test_execute_action_callback(self):
         """Test if execute method of ActionCallback calls correct callback method."""
-        xknx = XKNX(loop=self.loop)
+        xknx = XKNX()
         callback = Mock()
 
         async def async_callback():
@@ -97,7 +97,7 @@ async def async_callback():
 
     def test_execute_unknown_device(self):
         """Test if execute method of Action calls correct do method of device."""
-        xknx = XKNX(loop=self.loop)
+        xknx = XKNX()
 
         action = Action(xknx, target="Light1", method="on")
         with patch("logging.Logger.warning") as logger_warning_mock:

test/devices_tests/binary_sensor_test.py

@@ -32,7 +32,7 @@ def tearDown(self):
     #
     def test_process(self):
         """Test process / reading telegrams from telegram queue."""
-        xknx = XKNX(loop=self.loop)
+        xknx = XKNX()
         binaryinput = BinarySensor(xknx, "TestInput", "1/2/3")
 
         self.assertEqual(binaryinput.state, None)
@@ -61,7 +61,7 @@ def test_process(self):
 
     def test_process_reset_after(self):
         """Test process / reading telegrams from telegram queue."""
-        xknx = XKNX(loop=self.loop)
+        xknx = XKNX()
         reset_after_ms = 0.01
         binaryinput = BinarySensor(
             xknx, "TestInput", "1/2/3", reset_after=reset_after_ms
@@ -76,7 +76,7 @@ def test_process_reset_after(self):
 
     def test_process_action(self):
         """Test process / reading telegrams from telegram queue. Test if action is executed."""
-        xknx = XKNX(loop=self.loop)
+        xknx = XKNX()
         switch = Switch(xknx, "TestOutlet", group_address="1/2/3")
 
         binary_sensor = BinarySensor(xknx, "TestInput", group_address_state="1/2/3")
@@ -109,7 +109,7 @@ def test_process_action(self):
 
     def test_process_action_ignore_internal_state(self):
         """Test process / reading telegrams from telegram queue. Test if action is executed."""
-        xknx = XKNX(loop=self.loop)
+        xknx = XKNX()
         switch = Switch(xknx, "TestOutlet", group_address="5/5/5")
 
         binary_sensor = BinarySensor(
@@ -158,7 +158,7 @@ def test_process_action_ignore_internal_state(self):
 
     def test_process_wrong_payload(self):
         """Test process wrong telegram (wrong payload type)."""
-        xknx = XKNX(loop=self.loop)
+        xknx = XKNX()
         binary_sensor = BinarySensor(xknx, "Warning", group_address_state="1/2/3")
         telegram = Telegram(GroupAddress("1/2/3"), payload=DPTArray((0x1, 0x2, 0x3)))
         with self.assertRaises(CouldNotParseTelegram):
@@ -169,7 +169,7 @@ def test_process_wrong_payload(self):
     #
     def test_is_on(self):
         """Test is_on() and is_off() of a BinarySensor with state 'on'."""
-        xknx = XKNX(loop=self.loop)
+        xknx = XKNX()
         binaryinput = BinarySensor(xknx, "TestInput", "1/2/3")
         self.assertFalse(binaryinput.is_on())
         self.assertTrue(binaryinput.is_off())
@@ -184,7 +184,7 @@ def test_is_on(self):
     #
     def test_is_off(self):
         """Test is_on() and is_off() of a BinarySensor with state 'off'."""
-        xknx = XKNX(loop=self.loop)
+        xknx = XKNX()
         binaryinput = BinarySensor(xknx, "TestInput", "1/2/3")
         # pylint: disable=protected-access
         self.loop.run_until_complete(binaryinput._set_internal_state(False))
@@ -198,7 +198,7 @@ def test_is_off(self):
     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)
+        xknx = XKNX()
         switch = BinarySensor(xknx, "TestInput", group_address_state="1/2/3")
 
         after_update_callback = Mock()
@@ -219,7 +219,7 @@ async def async_after_update_callback(device):
     #
     def test_counter(self):
         """Test counter functionality."""
-        xknx = XKNX(loop=self.loop)
+        xknx = XKNX()
         switch = BinarySensor(xknx, "TestInput", group_address_state="1/2/3")
         with patch("time.time") as mock_time:
             mock_time.return_value = 1517000000.0