only use dropin configs when option config.dropins is true

Boolean option `config.dropins` must be set to `true` so that dropin
configs for the according config type are considered. So if the option
config.dropins=true in enabled in local config, only local dropin
configs are used (but no system or global ones).

Author: thorsten-klein

src/west/configuration.py

@@ -78,31 +78,34 @@ def from_path(path: Path | None) -> '_InternalCF | None':
 
     def __init__(self, path: Path):
         self.cp = _configparser()
-        self.dropin_cp = _configparser()
         self.path = path if path.exists() else None
-        dropin_dir = Path(f'{path}.d')
-        self.dropin_dir = dropin_dir if dropin_dir.exists() else None
+        if self.path:
+            self.cp.read(self.path, encoding='utf-8')
+
+        # consider dropin configs
+        self.dropin_cp = _configparser()
+        self.dropin_dir = None
         self.dropin_paths = []
-        if self.dropin_dir:
-            # dropin configs are applied in alphabetical order
-            for conf in sorted(self.dropin_dir.iterdir()):
-                # only consider .conf files
-                if conf.suffix.lower() in ['.conf', '.ini']:
-                    self.dropin_paths.append(self.dropin_dir / conf)
-        self._read()
+        # dropin configs must be enabled in config
+        if self.cp.getboolean('config', 'dropins', fallback=False):
+            # dropin dir is the config path with .d suffix
+            dropin_dir = Path(f'{path}.d')
+            self.dropin_dir = dropin_dir if dropin_dir.exists() else None
+            if self.dropin_dir:
+                # dropin configs are applied in alphabetical order
+                for conf in sorted(self.dropin_dir.iterdir()):
+                    # only consider .conf files
+                    if conf.suffix in ['.conf', '.ini']:
+                        self.dropin_paths.append(self.dropin_dir / conf)
+                if self.dropin_paths:
+                    self.dropin_cp.read(self.dropin_paths, encoding='utf-8')
 
     def _paths(self) -> list[Path]:
         ret = [p for p in self.dropin_paths]
         if self.path:
             ret.append(self.path)
         return ret
 
-    def _read(self):
-        if self.path:
-            self.cp.read(self.path, encoding='utf-8')
-        if self.dropin_paths:
-            self.dropin_cp.read(self.dropin_paths, encoding='utf-8')
-
     def _write(self):
         if not self.path:
             raise WestNotFound('No config file exists that can be written')

tests/test_config.py

@@ -156,7 +156,7 @@ def test_config_list_paths_extended():
         ''').splitlines()
     )
 
-    # create some dropins files
+    # create some dropin config files
     dropin_files = [
         pathlib.Path(WEST_CONFIG_GLOBAL + '.d') / 'a.conf',
         pathlib.Path(WEST_CONFIG_GLOBAL + '.d') / 'z.conf',
@@ -169,7 +169,23 @@ def test_config_list_paths_extended():
         dropin_file.parent.mkdir(exist_ok=True)
         dropin_file.touch()
 
-    # list the configs
+    # list the configs (dropin configs are not enabled by default)
+    stdout = cmd('config --list-paths')
+    assert (
+        stdout.splitlines()
+        == textwrap.dedent(f'''\
+        {WEST_CONFIG_GLOBAL}
+        {WEST_CONFIG_SYSTEM}
+        {WEST_CONFIG_LOCAL}
+        ''').splitlines()
+    )
+
+    # enable config.dropins for each config type
+    cmd('config --local config.dropins true')
+    cmd('config --global config.dropins true')
+    cmd('config --system config.dropins true')
+
+    # list the configs (consider dropin configs)
     stdout = cmd('config --list-paths')
     assert (
         stdout.splitlines()
@@ -186,10 +202,27 @@ def test_config_list_paths_extended():
         ''').splitlines()
     )
 
-    # print nothing if local config does not exist (exit code 0)
-    del os.environ['WEST_CONFIG_LOCAL']
-    stdout = cmd('config --local --print-path')
-    assert "" == stdout.rstrip()
+    # list the configs only when dropin configs are disabled
+    cmd('config --local config.dropins false')
+    cmd('config --global config.dropins false')
+    cmd('config --system config.dropins false')
+    stdout = cmd('config --list-paths')
+    assert (
+        stdout.splitlines()
+        == textwrap.dedent(f'''\
+        {WEST_CONFIG_GLOBAL}
+        {WEST_CONFIG_SYSTEM}
+        {WEST_CONFIG_LOCAL}
+        ''').splitlines()
+    )
+
+    # do not list any configs if no config files exist
+    # (Note: even no local config exists, same as outside any west workspace)
+    pathlib.Path(WEST_CONFIG_GLOBAL).unlink()
+    pathlib.Path(WEST_CONFIG_SYSTEM).unlink()
+    pathlib.Path(WEST_CONFIG_LOCAL).unlink()
+    stdout = cmd('config --list-paths')
+    assert stdout.splitlines() == []
 
 
 def test_config_local():
@@ -310,7 +343,7 @@ def test_local_creation():
     assert cfg(f=LOCAL)['pytest']['key'] == 'val'
 
 
-TEST_CASES_CONFIG_D = [
+TEST_CASES_DROPIN_CONFIGS = [
     # (flag, env_var)
     ('', 'WEST_CONFIG_LOCAL'),
     ('--local', 'WEST_CONFIG_LOCAL'),
@@ -319,16 +352,17 @@ def test_local_creation():
 ]
 
 
-@pytest.mark.parametrize("test_case", TEST_CASES_CONFIG_D)
-def test_config_d_local(test_case):
+@pytest.mark.parametrize("test_case", TEST_CASES_DROPIN_CONFIGS)
+def test_config_dropins(test_case):
     flag, env_var = test_case
     config_path = pathlib.Path(os.environ[env_var])
-    config_d_dir = pathlib.Path(f'{config_path}.d')
-    config_d_dir.mkdir()
+    dropin_configs_dir = pathlib.Path(f'{config_path}.d')
+    dropin_configs_dir.mkdir()
 
     # write value in actual config file
     cmd(f'config {flag} pytest.key val')
     cmd(f'config {flag} pytest.config-only val')
+    cmd(f'config {flag} config.dropins true')
 
     # read config value via command line
     stdout = cmd(f'config {flag} pytest.key')
@@ -344,10 +378,13 @@ def test_config_d_local(test_case):
         key = val
         config-only = val
 
+        [config]
+        dropins = true
+
         ''')
 
     # create a dropin config under .d
-    with open(config_d_dir / 'a.conf', 'w') as conf:
+    with open(dropin_configs_dir / 'a.conf', 'w') as conf:
         conf.write(
             textwrap.dedent('''
         [pytest]
@@ -358,7 +395,7 @@ def test_config_d_local(test_case):
         )
 
     # create a dropin config under .d
-    with open(config_d_dir / 'z.conf', 'w') as conf:
+    with open(dropin_configs_dir / 'z.conf', 'w') as conf:
         conf.write(
             textwrap.dedent('''
         [pytest]
@@ -390,16 +427,20 @@ def test_config_d_local(test_case):
         [pytest]
         key = val
 
+        [config]
+        dropins = true
+
         ''')
 
-    # remove config file
+    # remove config file and only set config.dropins true again
     config_path.unlink()
+    cmd(f'config {flag} config.dropins true')
 
     # values from config are unset now
     stderr = cmd_raises(f'config {flag} pytest.config-only', subprocess.CalledProcessError)
     assert 'ERROR: pytest.config-only is unset' == stderr.rstrip()
 
-    # dropin applies now, since config does not exist
+    # dropin config values are used now, since they are not set in config
     stdout = cmd(f'config {flag} pytest.key')
     assert 'from dropin a' == stdout.rstrip()
     # alphabetical order (z.conf is overwriting a.conf)
@@ -415,6 +456,15 @@ def test_config_d_local(test_case):
     # deletion of a value that is not existing anymore should fail
     cmd_raises(f'config {flag} -d pytest.config-only', subprocess.CalledProcessError)
 
+    # remove config (config.dropins is false by default)
+    config_path.unlink()
+
+    # values from dropin configs are not considered now
+    cmd_raises(f'config {flag} pytest.key', subprocess.CalledProcessError)
+    cmd_raises(f'config {flag} pytest.dropin-only', subprocess.CalledProcessError)
+    cmd_raises(f'config {flag} pytest.dropin-only-a', subprocess.CalledProcessError)
+    cmd_raises(f'config {flag} pytest.dropin-only-z', subprocess.CalledProcessError)
+
 
 def test_local_creation_with_topdir():
     # Like test_local_creation, with a specified topdir.