test/python/config/test_config.py

   1 # SPDX-License-Identifier: GPL-2.0-only
   2 #
   3 # This file is part of Nominatim. (https://nominatim.org)
   4 #
   5 # Copyright (C) 2022 by the Nominatim developer community.
   6 # For a full list of authors see the git log.
   7 """
   8 Test for loading dotenv configuration.
   9 """
  10 from pathlib import Path
  11 import pytest
  12
  13 from nominatim.config import Configuration, flatten_config_list
  14 from nominatim.errors import UsageError
  15
  16 @pytest.fixture
  17 def make_config(src_dir):
  18     """ Create a configuration object from the given project directory.
  19     """
  20     def _mk_config(project_dir=None):
  21         return Configuration(project_dir, src_dir / 'settings')
  22
  23     return _mk_config
  24
  25 @pytest.fixture
  26 def make_config_path(src_dir, tmp_path):
  27     """ Create a configuration object with project and config directories
  28         in a temporary directory.
  29     """
  30     def _mk_config():
  31         (tmp_path / 'project').mkdir()
  32         (tmp_path / 'config').mkdir()
  33         conf = Configuration(tmp_path / 'project', src_dir / 'settings')
  34         conf.config_dir = tmp_path / 'config'
  35         return conf
  36
  37     return _mk_config
  38
  39
  40 def test_no_project_dir(make_config):
  41     config = make_config()
  42
  43     assert config.DATABASE_WEBUSER == 'www-data'
  44
  45
  46 @pytest.mark.parametrize("val", ('apache', '"apache"'))
  47 def test_prefer_project_setting_over_default(make_config, val, tmp_path):
  48     envfile = tmp_path / '.env'
  49     envfile.write_text('NOMINATIM_DATABASE_WEBUSER={}\n'.format(val))
  50
  51     config = make_config(tmp_path)
  52
  53     assert config.DATABASE_WEBUSER == 'apache'
  54
  55
  56 def test_prefer_os_environ_over_project_setting(make_config, monkeypatch, tmp_path):
  57     envfile = tmp_path / '.env'
  58     envfile.write_text('NOMINATIM_DATABASE_WEBUSER=apache\n')
  59
  60     monkeypatch.setenv('NOMINATIM_DATABASE_WEBUSER', 'nobody')
  61
  62     config = make_config(tmp_path)
  63
  64     assert config.DATABASE_WEBUSER == 'nobody'
  65
  66
  67 def test_prefer_os_environ_can_unset_project_setting(make_config, monkeypatch, tmp_path):
  68     envfile = tmp_path / '.env'
  69     envfile.write_text('NOMINATIM_DATABASE_WEBUSER=apache\n')
  70
  71     monkeypatch.setenv('NOMINATIM_DATABASE_WEBUSER', '')
  72
  73     config = make_config(tmp_path)
  74
  75     assert config.DATABASE_WEBUSER == ''
  76
  77
  78 def test_get_os_env_add_defaults(make_config, monkeypatch):
  79     config = make_config()
  80
  81     monkeypatch.delenv('NOMINATIM_DATABASE_WEBUSER', raising=False)
  82
  83     assert config.get_os_env()['NOMINATIM_DATABASE_WEBUSER'] == 'www-data'
  84
  85
  86 def test_get_os_env_prefer_os_environ(make_config, monkeypatch):
  87     config = make_config()
  88
  89     monkeypatch.setenv('NOMINATIM_DATABASE_WEBUSER', 'nobody')
  90
  91     assert config.get_os_env()['NOMINATIM_DATABASE_WEBUSER'] == 'nobody'
  92
  93
  94 def test_get_libpq_dsn_convert_default(make_config):
  95     config = make_config()
  96
  97     assert config.get_libpq_dsn() == 'dbname=nominatim'
  98
  99
 100 def test_get_libpq_dsn_convert_php(make_config, monkeypatch):
 101     config = make_config()
 102
 103     monkeypatch.setenv('NOMINATIM_DATABASE_DSN',
 104                        'pgsql:dbname=gis;password=foo;host=localhost')
 105
 106     assert config.get_libpq_dsn() == 'dbname=gis password=foo host=localhost'
 107
 108
 109 @pytest.mark.parametrize("val,expect", [('foo bar', "'foo bar'"),
 110                                         ("xy'z", "xy\\'z"),
 111                                        ])
 112 def test_get_libpq_dsn_convert_php_special_chars(make_config, monkeypatch, val, expect):
 113     config = make_config()
 114
 115     monkeypatch.setenv('NOMINATIM_DATABASE_DSN',
 116                        'pgsql:dbname=gis;password={}'.format(val))
 117
 118     assert config.get_libpq_dsn() == "dbname=gis password={}".format(expect)
 119
 120
 121 def test_get_libpq_dsn_convert_libpq(make_config, monkeypatch):
 122     config = make_config()
 123
 124     monkeypatch.setenv('NOMINATIM_DATABASE_DSN',
 125                        'host=localhost dbname=gis password=foo')
 126
 127     assert config.get_libpq_dsn() == 'host=localhost dbname=gis password=foo'
 128
 129
 130 @pytest.mark.parametrize("value,result",
 131                          [(x, True) for x in ('1', 'true', 'True', 'yes', 'YES')] +
 132                          [(x, False) for x in ('0', 'false', 'no', 'NO', 'x')])
 133 def test_get_bool(make_config, monkeypatch, value, result):
 134     config = make_config()
 135
 136     monkeypatch.setenv('NOMINATIM_FOOBAR', value)
 137
 138     assert config.get_bool('FOOBAR') == result
 139
 140 def test_get_bool_empty(make_config):
 141     config = make_config()
 142
 143     assert config.DATABASE_MODULE_PATH == ''
 144     assert not config.get_bool('DATABASE_MODULE_PATH')
 145
 146
 147 @pytest.mark.parametrize("value,result", [('0', 0), ('1', 1),
 148                                           ('85762513444', 85762513444)])
 149 def test_get_int_success(make_config, monkeypatch, value, result):
 150     config = make_config()
 151
 152     monkeypatch.setenv('NOMINATIM_FOOBAR', value)
 153
 154     assert config.get_int('FOOBAR') == result
 155
 156
 157 @pytest.mark.parametrize("value", ['1b', 'fg', '0x23'])
 158 def test_get_int_bad_values(make_config, monkeypatch, value):
 159     config = make_config()
 160
 161     monkeypatch.setenv('NOMINATIM_FOOBAR', value)
 162
 163     with pytest.raises(UsageError):
 164         config.get_int('FOOBAR')
 165
 166
 167 def test_get_int_empty(make_config):
 168     config = make_config()
 169
 170     assert config.DATABASE_MODULE_PATH == ''
 171
 172     with pytest.raises(UsageError):
 173         config.get_int('DATABASE_MODULE_PATH')
 174
 175
 176 @pytest.mark.parametrize("value,outlist", [('sd', ['sd']),
 177                                            ('dd,rr', ['dd', 'rr']),
 178                                            (' a , b ', ['a', 'b'])])
 179 def test_get_str_list_success(make_config, monkeypatch, value, outlist):
 180     config = make_config()
 181
 182     monkeypatch.setenv('NOMINATIM_MYLIST', value)
 183
 184     assert config.get_str_list('MYLIST') == outlist
 185
 186
 187 def test_get_str_list_empty(make_config):
 188     config = make_config()
 189
 190     assert config.get_str_list('LANGUAGES') is None
 191
 192
 193 def test_get_path_empty(make_config):
 194     config = make_config()
 195
 196     assert config.DATABASE_MODULE_PATH == ''
 197     assert not config.get_path('DATABASE_MODULE_PATH')
 198
 199
 200 def test_get_path_absolute(make_config, monkeypatch):
 201     config = make_config()
 202
 203     monkeypatch.setenv('NOMINATIM_FOOBAR', '/dont/care')
 204     result = config.get_path('FOOBAR')
 205
 206     assert isinstance(result, Path)
 207     assert str(result) == '/dont/care'
 208
 209
 210 def test_get_path_relative(make_config, monkeypatch, tmp_path):
 211     config = make_config(tmp_path)
 212
 213     monkeypatch.setenv('NOMINATIM_FOOBAR', 'an/oyster')
 214     result = config.get_path('FOOBAR')
 215
 216     assert isinstance(result, Path)
 217     assert str(result) == str(tmp_path / 'an/oyster')
 218
 219
 220 def test_get_import_style_intern(make_config, src_dir, monkeypatch):
 221     config = make_config()
 222
 223     monkeypatch.setenv('NOMINATIM_IMPORT_STYLE', 'street')
 224
 225     expected = src_dir / 'settings' / 'import-street.style'
 226
 227     assert config.get_import_style_file() == expected
 228
 229
 230 def test_get_import_style_extern_relative(make_config_path, monkeypatch):
 231     config = make_config_path()
 232     (config.project_dir / 'custom.style').write_text('x')
 233
 234     monkeypatch.setenv('NOMINATIM_IMPORT_STYLE', 'custom.style')
 235
 236     assert str(config.get_import_style_file()) == str(config.project_dir / 'custom.style')
 237
 238
 239 def test_get_import_style_extern_absolute(make_config, tmp_path, monkeypatch):
 240     config = make_config()
 241     cfgfile = tmp_path / 'test.style'
 242
 243     cfgfile.write_text('x')
 244
 245     monkeypatch.setenv('NOMINATIM_IMPORT_STYLE', str(cfgfile))
 246
 247     assert str(config.get_import_style_file()) == str(cfgfile)
 248
 249
 250 def test_load_subconf_from_project_dir(make_config_path):
 251     config = make_config_path()
 252
 253     testfile = config.project_dir / 'test.yaml'
 254     testfile.write_text('cow: muh\ncat: miau\n')
 255
 256     testfile = config.config_dir / 'test.yaml'
 257     testfile.write_text('cow: miau\ncat: muh\n')
 258
 259     rules = config.load_sub_configuration('test.yaml')
 260
 261     assert rules == dict(cow='muh', cat='miau')
 262
 263
 264 def test_load_subconf_from_settings_dir(make_config_path):
 265     config = make_config_path()
 266
 267     testfile = config.config_dir / 'test.yaml'
 268     testfile.write_text('cow: muh\ncat: miau\n')
 269
 270     rules = config.load_sub_configuration('test.yaml')
 271
 272     assert rules == dict(cow='muh', cat='miau')
 273
 274
 275 def test_load_subconf_empty_env_conf(make_config_path, monkeypatch):
 276     monkeypatch.setenv('NOMINATIM_MY_CONFIG', '')
 277     config = make_config_path()
 278
 279     testfile = config.config_dir / 'test.yaml'
 280     testfile.write_text('cow: muh\ncat: miau\n')
 281
 282     rules = config.load_sub_configuration('test.yaml', config='MY_CONFIG')
 283
 284     assert rules == dict(cow='muh', cat='miau')
 285
 286
 287 def test_load_subconf_env_absolute_found(make_config_path, monkeypatch, tmp_path):
 288     monkeypatch.setenv('NOMINATIM_MY_CONFIG', str(tmp_path / 'other.yaml'))
 289     config = make_config_path()
 290
 291     (config.config_dir / 'test.yaml').write_text('cow: muh\ncat: miau\n')
 292     (tmp_path / 'other.yaml').write_text('dog: muh\nfrog: miau\n')
 293
 294     rules = config.load_sub_configuration('test.yaml', config='MY_CONFIG')
 295
 296     assert rules == dict(dog='muh', frog='miau')
 297
 298
 299 def test_load_subconf_env_absolute_not_found(make_config_path, monkeypatch, tmp_path):
 300     monkeypatch.setenv('NOMINATIM_MY_CONFIG', str(tmp_path / 'other.yaml'))
 301     config = make_config_path()
 302
 303     (config.config_dir / 'test.yaml').write_text('cow: muh\ncat: miau\n')
 304
 305     with pytest.raises(UsageError, match='Config file not found.'):
 306         rules = config.load_sub_configuration('test.yaml', config='MY_CONFIG')
 307
 308
 309 @pytest.mark.parametrize("location", ['project_dir', 'config_dir'])
 310 def test_load_subconf_env_relative_found(make_config_path, monkeypatch, location):
 311     monkeypatch.setenv('NOMINATIM_MY_CONFIG', 'other.yaml')
 312     config = make_config_path()
 313
 314     (config.config_dir / 'test.yaml').write_text('cow: muh\ncat: miau\n')
 315     (getattr(config, location) / 'other.yaml').write_text('dog: bark\n')
 316
 317     rules = config.load_sub_configuration('test.yaml', config='MY_CONFIG')
 318
 319     assert rules == dict(dog='bark')
 320
 321
 322 def test_load_subconf_env_relative_not_found(make_config_path, monkeypatch):
 323     monkeypatch.setenv('NOMINATIM_MY_CONFIG', 'other.yaml')
 324     config = make_config_path()
 325
 326     (config.config_dir / 'test.yaml').write_text('cow: muh\ncat: miau\n')
 327
 328     with pytest.raises(UsageError, match='Config file not found.'):
 329         rules = config.load_sub_configuration('test.yaml', config='MY_CONFIG')
 330
 331
 332 def test_load_subconf_json(make_config_path):
 333     config = make_config_path()
 334
 335     (config.project_dir / 'test.json').write_text('{"cow": "muh", "cat": "miau"}')
 336
 337     rules = config.load_sub_configuration('test.json')
 338
 339     assert rules == dict(cow='muh', cat='miau')
 340
 341 def test_load_subconf_not_found(make_config_path):
 342     config = make_config_path()
 343
 344     with pytest.raises(UsageError, match='Config file not found.'):
 345         config.load_sub_configuration('test.yaml')
 346
 347
 348 def test_load_subconf_env_unknown_format(make_config_path):
 349     config = make_config_path()
 350
 351     (config.project_dir / 'test.xml').write_text('<html></html>')
 352
 353     with pytest.raises(UsageError, match='unknown format'):
 354         config.load_sub_configuration('test.xml')
 355
 356
 357 def test_load_subconf_include_absolute(make_config_path, tmp_path):
 358     config = make_config_path()
 359
 360     testfile = config.config_dir / 'test.yaml'
 361     testfile.write_text(f'base: !include {tmp_path}/inc.yaml\n')
 362     (tmp_path / 'inc.yaml').write_text('first: 1\nsecond: 2\n')
 363
 364     rules = config.load_sub_configuration('test.yaml')
 365
 366     assert rules == dict(base=dict(first=1, second=2))
 367
 368
 369 @pytest.mark.parametrize("location", ['project_dir', 'config_dir'])
 370 def test_load_subconf_include_relative(make_config_path, tmp_path, location):
 371     config = make_config_path()
 372
 373     testfile = config.config_dir / 'test.yaml'
 374     testfile.write_text(f'base: !include inc.yaml\n')
 375     (getattr(config, location) / 'inc.yaml').write_text('first: 1\nsecond: 2\n')
 376
 377     rules = config.load_sub_configuration('test.yaml')
 378
 379     assert rules == dict(base=dict(first=1, second=2))
 380
 381
 382 def test_load_subconf_include_bad_format(make_config_path):
 383     config = make_config_path()
 384
 385     testfile = config.config_dir / 'test.yaml'
 386     testfile.write_text(f'base: !include inc.txt\n')
 387     (config.config_dir / 'inc.txt').write_text('first: 1\nsecond: 2\n')
 388
 389     with pytest.raises(UsageError, match='Cannot handle config file format.'):
 390         rules = config.load_sub_configuration('test.yaml')
 391
 392
 393 def test_load_subconf_include_not_found(make_config_path):
 394     config = make_config_path()
 395
 396     testfile = config.config_dir / 'test.yaml'
 397     testfile.write_text(f'base: !include inc.txt\n')
 398
 399     with pytest.raises(UsageError, match='Config file not found.'):
 400         rules = config.load_sub_configuration('test.yaml')
 401
 402
 403 def test_load_subconf_include_recursive(make_config_path):
 404     config = make_config_path()
 405
 406     testfile = config.config_dir / 'test.yaml'
 407     testfile.write_text(f'base: !include inc.yaml\n')
 408     (config.config_dir / 'inc.yaml').write_text('- !include more.yaml\n- upper\n')
 409     (config.config_dir / 'more.yaml').write_text('- the end\n')
 410
 411     rules = config.load_sub_configuration('test.yaml')
 412
 413     assert rules == dict(base=[['the end'], 'upper'])
 414
 415
 416 @pytest.mark.parametrize("content", [[], None])
 417 def test_flatten_config_list_empty(content):
 418     assert flatten_config_list(content) == []
 419
 420
 421 @pytest.mark.parametrize("content", [{'foo': 'bar'}, 'hello world', 3])
 422 def test_flatten_config_list_no_list(content):
 423     with pytest.raises(UsageError):
 424         flatten_config_list(content)
 425
 426
 427 def test_flatten_config_list_allready_flat():
 428     assert flatten_config_list([1, 2, 456]) == [1, 2, 456]
 429
 430
 431 def test_flatten_config_list_nested():
 432     content = [
 433         34,
 434         [{'first': '1st', 'second': '2nd'}, {}],
 435         [[2, 3], [45, [56, 78], 66]],
 436         'end'
 437     ]
 438     assert flatten_config_list(content) == \
 439                [34, {'first': '1st', 'second': '2nd'}, {},
 440                 2, 3, 45, 56, 78, 66, 'end']