Add the require_complete_init flag to control error handling during getting settings on application initialization

Author: aleksey925

pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "runtime-config-py"
-version = "0.0.7"
+version = "0.0.8"
 description = "Library for runtime updating project settings."
 license = "MIT"
 authors = ["Aleksey Petrunnik <petrunnik.a@gmail.com>"]

src/runtime_config/runtime_config.py

@@ -22,25 +22,36 @@
 
 
 class RuntimeConfig:
-    def __init__(self, init_settings: SettingsType, source: BaseSource, refresh_interval: float) -> None:
+    def __init__(
+        self,
+        init_settings: SettingsType,
+        source: BaseSource,
+        refresh_interval: float,
+        require_complete_init: bool = True,
+    ) -> None:
         self._init_settings: SettingsType = copy.deepcopy(init_settings)
-        self._settings: SettingsType = {}
+        self._settings: SettingsType = copy.deepcopy(init_settings)
+        self._initialized = False
 
         self._source = source
         self._settings_merger = SettingsMerger(init_settings=init_settings)
         self._periodic_refresh_task: asyncio.Task[None] = periodic_task(self.refresh, callback_time=refresh_interval)
+        self._require_complete_init = require_complete_init
 
     @staticmethod
     async def create(
         init_settings: t.Dict[str, t.Any],
         source: BaseSource | None = None,
         refresh_interval: float = 10,
+        require_complete_init: bool = True,
     ) -> RuntimeConfig:
         """
         Creates and initializes an instance of the class. You should always use this method to instantiate a class.
         :param init_settings: dictionary with default settings that you can then override.
         :param source: the source from which the actual values of the variables will be retrieved.
         :param refresh_interval: the frequency with which updates will be requested from the source.
+        :param require_complete_init: if set to true, exceptions that occur during the first time settings are
+        received from an external source will not be caught
         :return: initialized class instance.
         """
         if 'inst' in _instance:
@@ -56,24 +67,37 @@ async def create(
                 )
             source = sources.ConfigServerSrc(host=host, service_name=service_name)
 
-        inst = RuntimeConfig(init_settings=init_settings, source=source, refresh_interval=refresh_interval)
+        inst = RuntimeConfig(
+            init_settings=init_settings,
+            source=source,
+            refresh_interval=refresh_interval,
+            require_complete_init=require_complete_init,
+        )
         _instance['inst'] = inst
         await inst.refresh()
+        inst._initialized = True
         return inst
 
     async def refresh(self) -> None:
+        def _check_inst_initialization(inst: RuntimeConfig, exception: Exception) -> None:
+            if not inst._initialized and inst._require_complete_init:
+                raise exception
+
         extracted_settings = []
         try:
             extracted_settings = await self._source.get_settings()
         except ValidationError as exc:
-            logger.error(str(exc), exc_info=True)
-        except Exception:
-            logger.error('An unexpected error occurred while fetching new settings from the server', exc_info=True)
+            logger.error("Fetched not valid data from remote source", exc_info=True)
+            _check_inst_initialization(self, exc)
+        except Exception as exc:
+            logger.error('Fetching new settings from a remote source failed', exc_info=True)
+            _check_inst_initialization(self, exc)
 
         try:
             self._settings = await self._settings_merger.merge(extracted_settings=extracted_settings)
-        except Exception:
-            logger.error('An unexpected error occurred while merge settings', exc_info=True)
+        except Exception as exc:
+            logger.error('Merge settings error', exc_info=True)
+            _check_inst_initialization(self, exc)
 
     def get(self, setting_name: str, default: t.Any = None) -> t.Any:
         return self._settings.get(setting_name, default)

tests/test_runtime_config.py

@@ -211,11 +211,23 @@ async def test_refresh__failed_to_get_settings_from_server__config_is_initialize
         source_mock.get_settings.side_effect = exception
 
         # act
-        inst = await RuntimeConfig.create(init_settings=init_settings, source=source_mock)
+        inst = await RuntimeConfig.create(init_settings=init_settings, source=source_mock, require_complete_init=False)
 
         # assert
         assert inst._settings == init_settings
 
+    @pytest.mark.parametrize('exception', [ValidationError, Exception])
+    async def test_refresh__failed_to_get_settings_from_server__raise_exc(
+        self, mocker: MockerFixture, init_settings, source_mock, exception
+    ):
+        # arrange
+        mocker.patch.dict(_instance, clear=True)
+        source_mock.get_settings.side_effect = exception
+
+        # act && assert
+        with pytest.raises(exception):
+            await RuntimeConfig.create(init_settings=init_settings, source=source_mock)
+
     async def test_refresh__setting_value_cannot_be_converted_to_required_type__invalid_settings_skipped(
         self, mocker: MockerFixture, init_settings, source_mock
     ):
@@ -233,6 +245,38 @@ async def test_refresh__setting_value_cannot_be_converted_to_required_type__inva
         # assert
         assert inst._settings == init_settings
 
+    async def test_refresh__init_instance_successful_init_required_merge_error__raise_exc(
+        self, mocker: MockerFixture, init_settings, source_mock
+    ):
+        # arrange
+        expected_exception = Exception
+        mocker.patch.dict(_instance, clear=True)
+        source_mock.get_settings.return_value = [
+            Setting(name='some_var', value=1, value_type=SettingValueType.int, disable=False)
+        ]
+        mocker.patch('runtime_config.runtime_config.SettingsMerger._get_inner_dict', side_effect=expected_exception)
+
+        # act && assert
+        with pytest.raises(expected_exception):
+            await RuntimeConfig.create(init_settings=init_settings, source=source_mock)
+
+    async def test_refresh__init_instance_successful_init_not_required_merge_error__use_default_settings(
+        self, mocker: MockerFixture, init_settings, source_mock
+    ):
+        # arrange
+        expected_exception = Exception
+        mocker.patch.dict(_instance, clear=True)
+        source_mock.get_settings.return_value = [
+            Setting(name='some_var', value=1, value_type=SettingValueType.int, disable=False)
+        ]
+        mocker.patch('runtime_config.runtime_config.SettingsMerger._get_inner_dict', side_effect=expected_exception)
+
+        # act
+        inst = await RuntimeConfig.create(init_settings=init_settings, source=source_mock, require_complete_init=False)
+
+        # assert
+        assert inst._settings == init_settings
+
     async def test_refresh__unexpected_error_during_merge__previous_settings_are_not_changed(
         self, mocker: MockerFixture, init_settings, source_mock
     ):