diff --git a/test/python/conftest.py b/test/python/conftest.py index 969a6aaa..77093c4e 100644 --- a/test/python/conftest.py +++ b/test/python/conftest.py @@ -16,6 +16,7 @@ from nominatim.db import connection from nominatim.db.sql_preprocessor import SQLPreprocessor from nominatim.db import properties import nominatim.tokenizer.factory +import nominatim.cli import dummy_tokenizer import mocks @@ -104,10 +105,28 @@ def def_config(): data=SRC_DIR / 'data') return cfg + @pytest.fixture def src_dir(): return SRC_DIR.resolve() + +@pytest.fixture +def cli_call(): + def _call_nominatim(*args): + return nominatim.cli.nominatim( + module_dir='MODULE NOT AVAILABLE', + osm2pgsql_path='OSM2PGSQL NOT AVAILABLE', + phplib_dir=str(SRC_DIR / 'lib-php'), + data_dir=str(SRC_DIR / 'data'), + phpcgi_path='/usr/bin/php-cgi', + sqllib_dir=str(SRC_DIR / 'lib-sql'), + config_dir=str(SRC_DIR / 'settings'), + cli_args=args) + + return _call_nominatim + + @pytest.fixture def tmp_phplib_dir(): with tempfile.TemporaryDirectory() as phpdir: diff --git a/test/python/test_cli.py b/test/python/test_cli.py index 348ed9a3..c3625c4a 100644 --- a/test/python/test_cli.py +++ b/test/python/test_cli.py @@ -26,19 +26,6 @@ import nominatim.tokenizer.factory from mocks import MockParamCapture -SRC_DIR = (Path(__file__) / '..' / '..' / '..').resolve() - -def call_nominatim(*args): - return nominatim.cli.nominatim(module_dir='build/module', - osm2pgsql_path='build/osm2pgsql/osm2pgsql', - phplib_dir=str(SRC_DIR / 'lib-php'), - data_dir=str(SRC_DIR / 'data'), - phpcgi_path='/usr/bin/php-cgi', - sqllib_dir=str(SRC_DIR / 'lib-sql'), - config_dir=str(SRC_DIR / 'settings'), - cli_args=args) - - @pytest.fixture def mock_run_legacy(monkeypatch): mock = MockParamCapture() @@ -57,290 +44,311 @@ def mock_func_factory(monkeypatch): return get_mock -@pytest.fixture -def tokenizer_mock(monkeypatch): - class DummyTokenizer: - def __init__(self, *args, **kwargs): - self.update_sql_functions_called = False - self.finalize_import_called = False - def update_sql_functions(self, *args): - self.update_sql_functions_called = True +class TestCli: - def finalize_import(self, *args): - self.finalize_import_called = True + @pytest.fixture(autouse=True) + def setup_cli_call(self, cli_call): + self.call_nominatim = cli_call - tok = DummyTokenizer() - monkeypatch.setattr(nominatim.tokenizer.factory, 'get_tokenizer_for_db' , - lambda *args: tok) - monkeypatch.setattr(nominatim.tokenizer.factory, 'create_tokenizer' , - lambda *args: tok) - return tok + def test_cli_help(self, capsys): + """ Running nominatim tool without arguments prints help. + """ + assert 1 == self.call_nominatim() + captured = capsys.readouterr() + assert captured.out.startswith('usage:') -def test_cli_help(capsys): - """ Running nominatim tool without arguments prints help. - """ - assert 1 == call_nominatim() - captured = capsys.readouterr() - assert captured.out.startswith('usage:') + @pytest.mark.parametrize("command,script", [ + (('add-data', '--file', 'foo.osm'), 'update'), + (('export',), 'export') + ]) + def test_legacy_commands_simple(self, mock_run_legacy, command, script): + assert 0 == self.call_nominatim(*command) + assert mock_run_legacy.called == 1 + assert mock_run_legacy.last_args[0] == script + '.php' -@pytest.mark.parametrize("command,script", [ - (('add-data', '--file', 'foo.osm'), 'update'), - (('export',), 'export') - ]) -def test_legacy_commands_simple(mock_run_legacy, command, script): - assert 0 == call_nominatim(*command) - assert mock_run_legacy.called == 1 - assert mock_run_legacy.last_args[0] == script + '.php' + @pytest.mark.parametrize("params", [('--warm', ), + ('--warm', '--reverse-only'), + ('--warm', '--search-only')]) + def test_admin_command_legacy(self, mock_func_factory, params): + mock_run_legacy = mock_func_factory(nominatim.clicmd.admin, 'run_legacy_script') + assert 0 == self.call_nominatim('admin', *params) -def test_import_missing_file(temp_db): - assert 1 == call_nominatim('import', '--osm-file', 'sfsafegweweggdgw.reh.erh') + assert mock_run_legacy.called == 1 -def test_import_bad_file(temp_db): - assert 1 == call_nominatim('import', '--osm-file', '.') + def test_admin_command_check_database(self, mock_func_factory): + mock = mock_func_factory(nominatim.tools.check_database, 'check_database') + assert 0 == self.call_nominatim('admin', '--check-database') + assert mock.called == 1 -def test_import_full(temp_db, mock_func_factory, tokenizer_mock): - mocks = [ - mock_func_factory(nominatim.tools.database_import, 'setup_database_skeleton'), - mock_func_factory(nominatim.tools.database_import, 'import_osm_data'), - mock_func_factory(nominatim.tools.refresh, 'import_wikipedia_articles'), - mock_func_factory(nominatim.tools.database_import, 'truncate_data_tables'), - mock_func_factory(nominatim.tools.database_import, 'load_data'), - mock_func_factory(nominatim.tools.database_import, 'create_tables'), - mock_func_factory(nominatim.tools.database_import, 'create_table_triggers'), - mock_func_factory(nominatim.tools.database_import, 'create_partition_tables'), - mock_func_factory(nominatim.tools.database_import, 'create_search_indices'), - mock_func_factory(nominatim.tools.database_import, 'create_country_names'), - mock_func_factory(nominatim.tools.refresh, 'load_address_levels_from_file'), - mock_func_factory(nominatim.tools.postcodes, 'update_postcodes'), - mock_func_factory(nominatim.indexer.indexer.Indexer, 'index_full'), - mock_func_factory(nominatim.tools.refresh, 'setup_website'), - mock_func_factory(nominatim.db.properties, 'set_property') - ] - cf_mock = mock_func_factory(nominatim.tools.refresh, 'create_functions') + @pytest.mark.parametrize("name,oid", [('file', 'foo.osm'), ('diff', 'foo.osc'), + ('node', 12), ('way', 8), ('relation', 32)]) + def test_add_data_command(self, mock_run_legacy, name, oid): + assert 0 == self.call_nominatim('add-data', '--' + name, str(oid)) - assert 0 == call_nominatim('import', '--osm-file', __file__) - assert tokenizer_mock.finalize_import_called + assert mock_run_legacy.called == 1 + assert mock_run_legacy.last_args == ('update.php', '--import-' + name, oid) - assert cf_mock.called > 1 - for mock in mocks: - assert mock.called == 1, "Mock '{}' not called".format(mock.func_name) + def test_serve_command(self, mock_func_factory): + func = mock_func_factory(nominatim.cli, 'run_php_server') + self.call_nominatim('serve') -def test_import_continue_load_data(temp_db, mock_func_factory, tokenizer_mock): - mocks = [ - mock_func_factory(nominatim.tools.database_import, 'truncate_data_tables'), - mock_func_factory(nominatim.tools.database_import, 'load_data'), - mock_func_factory(nominatim.tools.database_import, 'create_search_indices'), - mock_func_factory(nominatim.tools.database_import, 'create_country_names'), - mock_func_factory(nominatim.tools.postcodes, 'update_postcodes'), - mock_func_factory(nominatim.indexer.indexer.Indexer, 'index_full'), - mock_func_factory(nominatim.tools.refresh, 'setup_website'), - mock_func_factory(nominatim.db.properties, 'set_property') - ] + assert func.called == 1 - assert 0 == call_nominatim('import', '--continue', 'load-data') - assert tokenizer_mock.finalize_import_called - for mock in mocks: - assert mock.called == 1, "Mock '{}' not called".format(mock.func_name) + @pytest.mark.parametrize("params", [ + ('search', '--query', 'new'), + ('reverse', '--lat', '0', '--lon', '0'), + ('lookup', '--id', 'N1'), + ('details', '--node', '1'), + ('details', '--way', '1'), + ('details', '--relation', '1'), + ('details', '--place_id', '10001'), + ('status',) + ]) + def test_api_commands_simple(self, mock_func_factory, params): + mock_run_api = mock_func_factory(nominatim.clicmd.api, 'run_api_script') + assert 0 == self.call_nominatim(*params) -def test_import_continue_indexing(temp_db, mock_func_factory, placex_table, - temp_db_conn, tokenizer_mock): - mocks = [ - mock_func_factory(nominatim.tools.database_import, 'create_search_indices'), - mock_func_factory(nominatim.tools.database_import, 'create_country_names'), - mock_func_factory(nominatim.indexer.indexer.Indexer, 'index_full'), - mock_func_factory(nominatim.tools.refresh, 'setup_website'), - mock_func_factory(nominatim.db.properties, 'set_property') - ] + assert mock_run_api.called == 1 + assert mock_run_api.last_args[0] == params[0] - assert 0 == call_nominatim('import', '--continue', 'indexing') - for mock in mocks: - assert mock.called == 1, "Mock '{}' not called".format(mock.func_name) - assert temp_db_conn.index_exists('idx_placex_pendingsector') +class TestCliWithDb: - # Calling it again still works for the index - assert 0 == call_nominatim('import', '--continue', 'indexing') - assert temp_db_conn.index_exists('idx_placex_pendingsector') + @pytest.fixture(autouse=True) + def setup_cli_call(self, cli_call, temp_db): + self.call_nominatim = cli_call -def test_import_continue_postprocess(temp_db, mock_func_factory, tokenizer_mock): - mocks = [ - mock_func_factory(nominatim.tools.database_import, 'create_search_indices'), - mock_func_factory(nominatim.tools.database_import, 'create_country_names'), - mock_func_factory(nominatim.tools.refresh, 'setup_website'), - mock_func_factory(nominatim.db.properties, 'set_property') - ] + @pytest.fixture(autouse=True) + def setup_tokenizer_mock(self, monkeypatch): + class DummyTokenizer: + def __init__(self, *args, **kwargs): + self.update_sql_functions_called = False + self.finalize_import_called = False - assert 0 == call_nominatim('import', '--continue', 'db-postprocess') + def update_sql_functions(self, *args): + self.update_sql_functions_called = True - assert tokenizer_mock.finalize_import_called + def finalize_import(self, *args): + self.finalize_import_called = True - for mock in mocks: - assert mock.called == 1, "Mock '{}' not called".format(mock.func_name) + tok = DummyTokenizer() + monkeypatch.setattr(nominatim.tokenizer.factory, 'get_tokenizer_for_db' , + lambda *args: tok) + monkeypatch.setattr(nominatim.tokenizer.factory, 'create_tokenizer' , + lambda *args: tok) + self.tokenizer_mock = tok -def test_freeze_command(mock_func_factory, temp_db): - mock_drop = mock_func_factory(nominatim.tools.freeze, 'drop_update_tables') - mock_flatnode = mock_func_factory(nominatim.tools.freeze, 'drop_flatnode_file') - assert 0 == call_nominatim('freeze') + def test_import_missing_file(self): + assert 1 == self.call_nominatim('import', '--osm-file', 'sfsafegweweggdgw.reh.erh') - assert mock_drop.called == 1 - assert mock_flatnode.called == 1 + def test_import_bad_file(self): + assert 1 == self.call_nominatim('import', '--osm-file', '.') -@pytest.mark.parametrize("params", [('--warm', ), - ('--warm', '--reverse-only'), - ('--warm', '--search-only')]) -def test_admin_command_legacy(mock_func_factory, params): - mock_run_legacy = mock_func_factory(nominatim.clicmd.admin, 'run_legacy_script') - assert 0 == call_nominatim('admin', *params) + def test_import_full(self, mock_func_factory): + mocks = [ + mock_func_factory(nominatim.tools.database_import, 'setup_database_skeleton'), + mock_func_factory(nominatim.tools.database_import, 'import_osm_data'), + mock_func_factory(nominatim.tools.refresh, 'import_wikipedia_articles'), + mock_func_factory(nominatim.tools.database_import, 'truncate_data_tables'), + mock_func_factory(nominatim.tools.database_import, 'load_data'), + mock_func_factory(nominatim.tools.database_import, 'create_tables'), + mock_func_factory(nominatim.tools.database_import, 'create_table_triggers'), + mock_func_factory(nominatim.tools.database_import, 'create_partition_tables'), + mock_func_factory(nominatim.tools.database_import, 'create_search_indices'), + mock_func_factory(nominatim.tools.database_import, 'create_country_names'), + mock_func_factory(nominatim.tools.refresh, 'load_address_levels_from_file'), + mock_func_factory(nominatim.tools.postcodes, 'update_postcodes'), + mock_func_factory(nominatim.indexer.indexer.Indexer, 'index_full'), + mock_func_factory(nominatim.tools.refresh, 'setup_website'), + mock_func_factory(nominatim.db.properties, 'set_property') + ] - assert mock_run_legacy.called == 1 + cf_mock = mock_func_factory(nominatim.tools.refresh, 'create_functions') + assert 0 == self.call_nominatim('import', '--osm-file', __file__) + assert self.tokenizer_mock.finalize_import_called -@pytest.mark.parametrize("func, params", [('analyse_indexing', ('--analyse-indexing', ))]) -def test_admin_command_tool(temp_db, mock_func_factory, func, params): - mock = mock_func_factory(nominatim.tools.admin, func) + assert cf_mock.called > 1 - assert 0 == call_nominatim('admin', *params) - assert mock.called == 1 + for mock in mocks: + assert mock.called == 1, "Mock '{}' not called".format(mock.func_name) -def test_admin_command_check_database(mock_func_factory): - mock = mock_func_factory(nominatim.tools.check_database, 'check_database') + def test_import_continue_load_data(self, mock_func_factory): + mocks = [ + mock_func_factory(nominatim.tools.database_import, 'truncate_data_tables'), + mock_func_factory(nominatim.tools.database_import, 'load_data'), + mock_func_factory(nominatim.tools.database_import, 'create_search_indices'), + mock_func_factory(nominatim.tools.database_import, 'create_country_names'), + mock_func_factory(nominatim.tools.postcodes, 'update_postcodes'), + mock_func_factory(nominatim.indexer.indexer.Indexer, 'index_full'), + mock_func_factory(nominatim.tools.refresh, 'setup_website'), + mock_func_factory(nominatim.db.properties, 'set_property') + ] - assert 0 == call_nominatim('admin', '--check-database') - assert mock.called == 1 + assert 0 == self.call_nominatim('import', '--continue', 'load-data') + assert self.tokenizer_mock.finalize_import_called + for mock in mocks: + assert mock.called == 1, "Mock '{}' not called".format(mock.func_name) -@pytest.mark.parametrize("name,oid", [('file', 'foo.osm'), ('diff', 'foo.osc'), - ('node', 12), ('way', 8), ('relation', 32)]) -def test_add_data_command(mock_run_legacy, name, oid): - assert 0 == call_nominatim('add-data', '--' + name, str(oid)) - assert mock_run_legacy.called == 1 - assert mock_run_legacy.last_args == ('update.php', '--import-' + name, oid) + def test_import_continue_indexing(self, mock_func_factory, placex_table, + temp_db_conn): + mocks = [ + mock_func_factory(nominatim.tools.database_import, 'create_search_indices'), + mock_func_factory(nominatim.tools.database_import, 'create_country_names'), + mock_func_factory(nominatim.indexer.indexer.Indexer, 'index_full'), + mock_func_factory(nominatim.tools.refresh, 'setup_website'), + mock_func_factory(nominatim.db.properties, 'set_property') + ] + assert 0 == self.call_nominatim('import', '--continue', 'indexing') -@pytest.mark.parametrize("params,do_bnds,do_ranks", [ - ([], 1, 1), - (['--boundaries-only'], 1, 0), - (['--no-boundaries'], 0, 1), - (['--boundaries-only', '--no-boundaries'], 0, 0)]) -def test_index_command(mock_func_factory, table_factory, tokenizer_mock, - params, do_bnds, do_ranks): - table_factory('import_status', 'indexed bool') - bnd_mock = mock_func_factory(nominatim.indexer.indexer.Indexer, 'index_boundaries') - rank_mock = mock_func_factory(nominatim.indexer.indexer.Indexer, 'index_by_rank') + for mock in mocks: + assert mock.called == 1, "Mock '{}' not called".format(mock.func_name) - assert 0 == call_nominatim('index', *params) + assert temp_db_conn.index_exists('idx_placex_pendingsector') - assert bnd_mock.called == do_bnds - assert rank_mock.called == do_ranks + # Calling it again still works for the index + assert 0 == self.call_nominatim('import', '--continue', 'indexing') + assert temp_db_conn.index_exists('idx_placex_pendingsector') -@pytest.mark.parametrize("no_replace", [(True), (False)]) -def test_special_phrases_wiki_command(temp_db, mock_func_factory, tokenizer_mock, no_replace): - func = mock_func_factory(nominatim.clicmd.special_phrases.SPImporter, 'import_phrases') - if no_replace: - call_nominatim('special-phrases', '--import-from-wiki', '--no-replace') - else: - call_nominatim('special-phrases', '--import-from-wiki') + def test_import_continue_postprocess(self, mock_func_factory): + mocks = [ + mock_func_factory(nominatim.tools.database_import, 'create_search_indices'), + mock_func_factory(nominatim.tools.database_import, 'create_country_names'), + mock_func_factory(nominatim.tools.refresh, 'setup_website'), + mock_func_factory(nominatim.db.properties, 'set_property') + ] - assert func.called == 1 + assert 0 == self.call_nominatim('import', '--continue', 'db-postprocess') -@pytest.mark.parametrize("no_replace", [(True), (False)]) -def test_special_phrases_csv_command(temp_db, mock_func_factory, tokenizer_mock, no_replace): - func = mock_func_factory(nominatim.clicmd.special_phrases.SPImporter, 'import_phrases') - testdata = SRC_DIR / 'test' / 'testdb' - csv_path = str((testdata / 'full_en_phrases_test.csv').resolve()) + assert self.tokenizer_mock.finalize_import_called - if no_replace: - call_nominatim('special-phrases', '--import-from-csv', csv_path, '--no-replace') - else: - call_nominatim('special-phrases', '--import-from-csv', csv_path) + for mock in mocks: + assert mock.called == 1, "Mock '{}' not called".format(mock.func_name) - assert func.called == 1 -@pytest.mark.parametrize("command,func", [ - ('word-counts', 'recompute_word_counts'), - ('address-levels', 'load_address_levels_from_file'), - ('wiki-data', 'import_wikipedia_articles'), - ('importance', 'recompute_importance'), - ('website', 'setup_website'), - ]) -def test_refresh_command(mock_func_factory, temp_db, command, func, tokenizer_mock): - func_mock = mock_func_factory(nominatim.tools.refresh, func) + def test_freeze_command(self, mock_func_factory): + mock_drop = mock_func_factory(nominatim.tools.freeze, 'drop_update_tables') + mock_flatnode = mock_func_factory(nominatim.tools.freeze, 'drop_flatnode_file') - assert 0 == call_nominatim('refresh', '--' + command) - assert func_mock.called == 1 + assert 0 == self.call_nominatim('freeze') + assert mock_drop.called == 1 + assert mock_flatnode.called == 1 -def test_refresh_postcodes(mock_func_factory, temp_db, tokenizer_mock): - func_mock = mock_func_factory(nominatim.tools.postcodes, 'update_postcodes') - idx_mock = mock_func_factory(nominatim.indexer.indexer.Indexer, 'index_postcodes') - assert 0 == call_nominatim('refresh', '--postcodes') - assert func_mock.called == 1 -def test_refresh_create_functions(mock_func_factory, temp_db, tokenizer_mock): - func_mock = mock_func_factory(nominatim.tools.refresh, 'create_functions') + @pytest.mark.parametrize("func, params", [('analyse_indexing', ('--analyse-indexing', ))]) + def test_admin_command_tool(self, mock_func_factory, func, params): + mock = mock_func_factory(nominatim.tools.admin, func) - assert 0 == call_nominatim('refresh', '--functions') - assert func_mock.called == 1 - assert tokenizer_mock.update_sql_functions_called + assert 0 == self.call_nominatim('admin', *params) + assert mock.called == 1 -def test_refresh_importance_computed_after_wiki_import(monkeypatch, temp_db, tokenizer_mock): - calls = [] - monkeypatch.setattr(nominatim.tools.refresh, 'import_wikipedia_articles', - lambda *args, **kwargs: calls.append('import') or 0) - monkeypatch.setattr(nominatim.tools.refresh, 'recompute_importance', - lambda *args, **kwargs: calls.append('update')) + @pytest.mark.parametrize("params,do_bnds,do_ranks", [ + ([], 1, 1), + (['--boundaries-only'], 1, 0), + (['--no-boundaries'], 0, 1), + (['--boundaries-only', '--no-boundaries'], 0, 0)]) + def test_index_command(self, mock_func_factory, table_factory, + params, do_bnds, do_ranks): + table_factory('import_status', 'indexed bool') + bnd_mock = mock_func_factory(nominatim.indexer.indexer.Indexer, 'index_boundaries') + rank_mock = mock_func_factory(nominatim.indexer.indexer.Indexer, 'index_by_rank') - assert 0 == call_nominatim('refresh', '--importance', '--wiki-data') + assert 0 == self.call_nominatim('index', *params) - assert calls == ['import', 'update'] + assert bnd_mock.called == do_bnds + assert rank_mock.called == do_ranks + @pytest.mark.parametrize("no_replace", [(True), (False)]) + def test_special_phrases_wiki_command(self, mock_func_factory, no_replace): + func = mock_func_factory(nominatim.clicmd.special_phrases.SPImporter, 'import_phrases') -def test_serve_command(mock_func_factory): - func = mock_func_factory(nominatim.cli, 'run_php_server') + if no_replace: + self.call_nominatim('special-phrases', '--import-from-wiki', '--no-replace') + else: + self.call_nominatim('special-phrases', '--import-from-wiki') - call_nominatim('serve') + assert func.called == 1 - assert func.called == 1 + @pytest.mark.parametrize("no_replace", [(True), (False)]) + def test_special_phrases_csv_command(self, src_dir, mock_func_factory, no_replace): + func = mock_func_factory(nominatim.clicmd.special_phrases.SPImporter, 'import_phrases') + testdata = src_dir / 'test' / 'testdb' + csv_path = str((testdata / 'full_en_phrases_test.csv').resolve()) + + if no_replace: + self.call_nominatim('special-phrases', '--import-from-csv', csv_path, '--no-replace') + else: + self.call_nominatim('special-phrases', '--import-from-csv', csv_path) + + assert func.called == 1 + + @pytest.mark.parametrize("command,func", [ + ('word-counts', 'recompute_word_counts'), + ('address-levels', 'load_address_levels_from_file'), + ('wiki-data', 'import_wikipedia_articles'), + ('importance', 'recompute_importance'), + ('website', 'setup_website'), + ]) + def test_refresh_command(self, mock_func_factory, command, func): + func_mock = mock_func_factory(nominatim.tools.refresh, func) + + assert 0 == self.call_nominatim('refresh', '--' + command) + assert func_mock.called == 1 + + + def test_refresh_postcodes(self, mock_func_factory): + func_mock = mock_func_factory(nominatim.tools.postcodes, 'update_postcodes') + idx_mock = mock_func_factory(nominatim.indexer.indexer.Indexer, 'index_postcodes') + + assert 0 == self.call_nominatim('refresh', '--postcodes') + assert func_mock.called == 1 + + def test_refresh_create_functions(self, mock_func_factory): + func_mock = mock_func_factory(nominatim.tools.refresh, 'create_functions') + + assert 0 == self.call_nominatim('refresh', '--functions') + assert func_mock.called == 1 + assert self.tokenizer_mock.update_sql_functions_called + + + def test_refresh_importance_computed_after_wiki_import(self, monkeypatch): + calls = [] + monkeypatch.setattr(nominatim.tools.refresh, 'import_wikipedia_articles', + lambda *args, **kwargs: calls.append('import') or 0) + monkeypatch.setattr(nominatim.tools.refresh, 'recompute_importance', + lambda *args, **kwargs: calls.append('update')) + + assert 0 == self.call_nominatim('refresh', '--importance', '--wiki-data') + + assert calls == ['import', 'update'] -@pytest.mark.parametrize("params", [ - ('search', '--query', 'new'), - ('reverse', '--lat', '0', '--lon', '0'), - ('lookup', '--id', 'N1'), - ('details', '--node', '1'), - ('details', '--way', '1'), - ('details', '--relation', '1'), - ('details', '--place_id', '10001'), - ('status',) - ]) -def test_api_commands_simple(mock_func_factory, params): - mock_run_api = mock_func_factory(nominatim.clicmd.api, 'run_api_script') - assert 0 == call_nominatim(*params) - assert mock_run_api.called == 1 - assert mock_run_api.last_args[0] == params[0] diff --git a/test/python/test_cli_replication.py b/test/python/test_cli_replication.py index b95e6ede..ebb89443 100644 --- a/test/python/test_cli_replication.py +++ b/test/python/test_cli_replication.py @@ -14,18 +14,6 @@ from nominatim.db import status from mocks import MockParamCapture -SRC_DIR = (Path(__file__) / '..' / '..' / '..').resolve() - -def call_nominatim(*args): - return nominatim.cli.nominatim(module_dir='build/module', - osm2pgsql_path='build/osm2pgsql/osm2pgsql', - phplib_dir=str(SRC_DIR / 'lib-php'), - data_dir=str(SRC_DIR / 'data'), - phpcgi_path='/usr/bin/php-cgi', - sqllib_dir=str(SRC_DIR / 'lib-sql'), - config_dir=str(SRC_DIR / 'settings'), - cli_args=['replication'] + list(args)) - @pytest.fixture def tokenizer_mock(monkeypatch): class DummyTokenizer: @@ -77,73 +65,80 @@ def init_status(temp_db_conn, status_table): def update_mock(mock_func_factory, init_status, tokenizer_mock): return mock_func_factory(nominatim.tools.replication, 'update') -@pytest.mark.parametrize("params,func", [ - (('--init', '--no-update-functions'), 'init_replication'), - (('--check-for-updates',), 'check_for_updates') - ]) -def test_replication_command(mock_func_factory, temp_db, params, func): - func_mock = mock_func_factory(nominatim.tools.replication, func) - assert 0 == call_nominatim(*params) - assert func_mock.called == 1 +class TestCliReplication: + + @pytest.fixture(autouse=True) + def setup_cli_call(self, cli_call, temp_db): + self.call_nominatim = lambda *args: cli_call('replication', *args) + + @pytest.mark.parametrize("params,func", [ + (('--init', '--no-update-functions'), 'init_replication'), + (('--check-for-updates',), 'check_for_updates') + ]) + def test_replication_command(self, mock_func_factory, params, func): + func_mock = mock_func_factory(nominatim.tools.replication, func) + + assert 0 == self.call_nominatim(*params) + assert func_mock.called == 1 -def test_replication_update_bad_interval(monkeypatch, temp_db): - monkeypatch.setenv('NOMINATIM_REPLICATION_UPDATE_INTERVAL', 'xx') + def test_replication_update_bad_interval(self, monkeypatch): + monkeypatch.setenv('NOMINATIM_REPLICATION_UPDATE_INTERVAL', 'xx') - assert call_nominatim() == 1 + assert self.call_nominatim() == 1 -def test_replication_update_bad_interval_for_geofabrik(monkeypatch, temp_db): - monkeypatch.setenv('NOMINATIM_REPLICATION_URL', - 'https://download.geofabrik.de/europe/ireland-and-northern-ireland-updates') + def test_replication_update_bad_interval_for_geofabrik(self, monkeypatch): + monkeypatch.setenv('NOMINATIM_REPLICATION_URL', + 'https://download.geofabrik.de/europe/ireland-and-northern-ireland-updates') - assert call_nominatim() == 1 + assert self.call_nominatim() == 1 -def test_replication_update_once_no_index(update_mock): - assert 0 == call_nominatim('--once', '--no-index') + def test_replication_update_once_no_index(self, update_mock): + assert 0 == self.call_nominatim('--once', '--no-index') - assert str(update_mock.last_args[1]['osm2pgsql']) == 'build/osm2pgsql/osm2pgsql' + assert str(update_mock.last_args[1]['osm2pgsql']) == 'OSM2PGSQL NOT AVAILABLE' -def test_replication_update_custom_osm2pgsql(monkeypatch, update_mock): - monkeypatch.setenv('NOMINATIM_OSM2PGSQL_BINARY', '/secret/osm2pgsql') - assert 0 == call_nominatim('--once', '--no-index') + def test_replication_update_custom_osm2pgsql(self, monkeypatch, update_mock): + monkeypatch.setenv('NOMINATIM_OSM2PGSQL_BINARY', '/secret/osm2pgsql') + assert 0 == self.call_nominatim('--once', '--no-index') - assert str(update_mock.last_args[1]['osm2pgsql']) == '/secret/osm2pgsql' + assert str(update_mock.last_args[1]['osm2pgsql']) == '/secret/osm2pgsql' -def test_replication_update_custom_threads(update_mock): - assert 0 == call_nominatim('--once', '--no-index', '--threads', '4') + def test_replication_update_custom_threads(self, update_mock): + assert 0 == self.call_nominatim('--once', '--no-index', '--threads', '4') - assert update_mock.last_args[1]['threads'] == 4 + assert update_mock.last_args[1]['threads'] == 4 -def test_replication_update_continuous(monkeypatch, init_status, index_mock): - states = [nominatim.tools.replication.UpdateState.UP_TO_DATE, - nominatim.tools.replication.UpdateState.UP_TO_DATE] - monkeypatch.setattr(nominatim.tools.replication, 'update', - lambda *args, **kwargs: states.pop()) + def test_replication_update_continuous(self, monkeypatch, init_status, index_mock): + states = [nominatim.tools.replication.UpdateState.UP_TO_DATE, + nominatim.tools.replication.UpdateState.UP_TO_DATE] + monkeypatch.setattr(nominatim.tools.replication, 'update', + lambda *args, **kwargs: states.pop()) - with pytest.raises(IndexError): - call_nominatim() + with pytest.raises(IndexError): + self.call_nominatim() - assert index_mock.called == 4 + assert index_mock.called == 4 -def test_replication_update_continuous_no_change(monkeypatch, init_status, index_mock): - states = [nominatim.tools.replication.UpdateState.NO_CHANGES, - nominatim.tools.replication.UpdateState.UP_TO_DATE] - monkeypatch.setattr(nominatim.tools.replication, 'update', - lambda *args, **kwargs: states.pop()) + def test_replication_update_continuous_no_change(self, monkeypatch, init_status, index_mock): + states = [nominatim.tools.replication.UpdateState.NO_CHANGES, + nominatim.tools.replication.UpdateState.UP_TO_DATE] + monkeypatch.setattr(nominatim.tools.replication, 'update', + lambda *args, **kwargs: states.pop()) - sleep_mock = MockParamCapture() - monkeypatch.setattr(time, 'sleep', sleep_mock) + sleep_mock = MockParamCapture() + monkeypatch.setattr(time, 'sleep', sleep_mock) - with pytest.raises(IndexError): - call_nominatim() + with pytest.raises(IndexError): + self.call_nominatim() - assert index_mock.called == 2 - assert sleep_mock.called == 1 - assert sleep_mock.last_args[0] == 60 + assert index_mock.called == 2 + assert sleep_mock.called == 1 + assert sleep_mock.last_args[0] == 60 diff --git a/test/python/test_config.py b/test/python/test_config.py index d6911957..cd828e14 100644 --- a/test/python/test_config.py +++ b/test/python/test_config.py @@ -8,59 +8,67 @@ import pytest from nominatim.config import Configuration from nominatim.errors import UsageError -DEFCFG_DIR = Path(__file__) / '..' / '..' / '..' / 'settings' +@pytest.fixture +def make_config(src_dir): + """ Create a configuration object from the given project directory. + """ + def _mk_config(project_dir=None): + return Configuration(project_dir, src_dir / 'settings') -def test_no_project_dir(): - config = Configuration(None, DEFCFG_DIR) + return _mk_config + + +def test_no_project_dir(make_config): + config = make_config() assert config.DATABASE_WEBUSER == 'www-data' @pytest.mark.parametrize("val", ('apache', '"apache"')) -def test_prefer_project_setting_over_default(val, tmp_path): +def test_prefer_project_setting_over_default(make_config, val, tmp_path): envfile = tmp_path / '.env' envfile.write_text('NOMINATIM_DATABASE_WEBUSER={}\n'.format(val)) - config = Configuration(Path(tmp_path), DEFCFG_DIR) + config = make_config(tmp_path) assert config.DATABASE_WEBUSER == 'apache' -def test_prefer_os_environ_over_project_setting(monkeypatch, tmp_path): +def test_prefer_os_environ_over_project_setting(make_config, monkeypatch, tmp_path): envfile = tmp_path / '.env' envfile.write_text('NOMINATIM_DATABASE_WEBUSER=apache\n') monkeypatch.setenv('NOMINATIM_DATABASE_WEBUSER', 'nobody') - config = Configuration(Path(tmp_path), DEFCFG_DIR) + config = make_config(tmp_path) assert config.DATABASE_WEBUSER == 'nobody' -def test_get_os_env_add_defaults(monkeypatch): - config = Configuration(None, DEFCFG_DIR) +def test_get_os_env_add_defaults(make_config, monkeypatch): + config = make_config() monkeypatch.delenv('NOMINATIM_DATABASE_WEBUSER', raising=False) assert config.get_os_env()['NOMINATIM_DATABASE_WEBUSER'] == 'www-data' -def test_get_os_env_prefer_os_environ(monkeypatch): - config = Configuration(None, DEFCFG_DIR) +def test_get_os_env_prefer_os_environ(make_config, monkeypatch): + config = make_config() monkeypatch.setenv('NOMINATIM_DATABASE_WEBUSER', 'nobody') assert config.get_os_env()['NOMINATIM_DATABASE_WEBUSER'] == 'nobody' -def test_get_libpq_dsn_convert_default(): - config = Configuration(None, DEFCFG_DIR) +def test_get_libpq_dsn_convert_default(make_config): + config = make_config() assert config.get_libpq_dsn() == 'dbname=nominatim' -def test_get_libpq_dsn_convert_php(monkeypatch): - config = Configuration(None, DEFCFG_DIR) +def test_get_libpq_dsn_convert_php(make_config, monkeypatch): + config = make_config() monkeypatch.setenv('NOMINATIM_DATABASE_DSN', 'pgsql:dbname=gis;password=foo;host=localhost') @@ -71,8 +79,8 @@ def test_get_libpq_dsn_convert_php(monkeypatch): @pytest.mark.parametrize("val,expect", [('foo bar', "'foo bar'"), ("xy'z", "xy\\'z"), ]) -def test_get_libpq_dsn_convert_php_special_chars(monkeypatch, val, expect): - config = Configuration(None, DEFCFG_DIR) +def test_get_libpq_dsn_convert_php_special_chars(make_config, monkeypatch, val, expect): + config = make_config() monkeypatch.setenv('NOMINATIM_DATABASE_DSN', 'pgsql:dbname=gis;password={}'.format(val)) @@ -80,8 +88,8 @@ def test_get_libpq_dsn_convert_php_special_chars(monkeypatch, val, expect): assert config.get_libpq_dsn() == "dbname=gis password={}".format(expect) -def test_get_libpq_dsn_convert_libpq(monkeypatch): - config = Configuration(None, DEFCFG_DIR) +def test_get_libpq_dsn_convert_libpq(make_config, monkeypatch): + config = make_config() monkeypatch.setenv('NOMINATIM_DATABASE_DSN', 'host=localhost dbname=gis password=foo') @@ -92,15 +100,15 @@ def test_get_libpq_dsn_convert_libpq(monkeypatch): @pytest.mark.parametrize("value,result", [(x, True) for x in ('1', 'true', 'True', 'yes', 'YES')] + [(x, False) for x in ('0', 'false', 'no', 'NO', 'x')]) -def test_get_bool(monkeypatch, value, result): - config = Configuration(None, DEFCFG_DIR) +def test_get_bool(make_config, monkeypatch, value, result): + config = make_config() monkeypatch.setenv('NOMINATIM_FOOBAR', value) assert config.get_bool('FOOBAR') == result -def test_get_bool_empty(): - config = Configuration(None, DEFCFG_DIR) +def test_get_bool_empty(make_config): + config = make_config() assert config.DATABASE_MODULE_PATH == '' assert config.get_bool('DATABASE_MODULE_PATH') == False @@ -108,8 +116,8 @@ def test_get_bool_empty(): @pytest.mark.parametrize("value,result", [('0', 0), ('1', 1), ('85762513444', 85762513444)]) -def test_get_int_success(monkeypatch, value, result): - config = Configuration(None, DEFCFG_DIR) +def test_get_int_success(make_config, monkeypatch, value, result): + config = make_config() monkeypatch.setenv('NOMINATIM_FOOBAR', value) @@ -117,8 +125,8 @@ def test_get_int_success(monkeypatch, value, result): @pytest.mark.parametrize("value", ['1b', 'fg', '0x23']) -def test_get_int_bad_values(monkeypatch, value): - config = Configuration(None, DEFCFG_DIR) +def test_get_int_bad_values(make_config, monkeypatch, value): + config = make_config() monkeypatch.setenv('NOMINATIM_FOOBAR', value) @@ -126,8 +134,8 @@ def test_get_int_bad_values(monkeypatch, value): config.get_int('FOOBAR') -def test_get_int_empty(): - config = Configuration(None, DEFCFG_DIR) +def test_get_int_empty(make_config): + config = make_config() assert config.DATABASE_MODULE_PATH == '' @@ -135,8 +143,8 @@ def test_get_int_empty(): config.get_int('DATABASE_MODULE_PATH') -def test_get_import_style_intern(monkeypatch): - config = Configuration(None, DEFCFG_DIR) +def test_get_import_style_intern(make_config, monkeypatch): + config = make_config() monkeypatch.setenv('NOMINATIM_IMPORT_STYLE', 'street') @@ -146,8 +154,8 @@ def test_get_import_style_intern(monkeypatch): @pytest.mark.parametrize("value", ['custom', '/foo/bar.stye']) -def test_get_import_style_intern(monkeypatch, value): - config = Configuration(None, DEFCFG_DIR) +def test_get_import_style_intern(make_config, monkeypatch, value): + config = make_config() monkeypatch.setenv('NOMINATIM_IMPORT_STYLE', value) diff --git a/test/python/test_tools_import_special_phrases.py b/test/python/test_tools_import_special_phrases.py index fe996a61..b3c60029 100644 --- a/test/python/test_tools_import_special_phrases.py +++ b/test/python/test_tools_import_special_phrases.py @@ -14,7 +14,52 @@ from nominatim.tools.special_phrases.special_phrase import SpecialPhrase from cursor import CursorForTesting -TEST_BASE_DIR = Path(__file__) / '..' / '..' +@pytest.fixture +def testfile_dir(src_dir): + return src_dir / 'test' / 'testfiles' + + +@pytest.fixture +def sp_importer(temp_db_conn, def_config, temp_phplib_dir_with_migration): + """ + Return an instance of SPImporter. + """ + loader = SPWikiLoader(def_config, ['en']) + return SPImporter(def_config, temp_phplib_dir_with_migration, temp_db_conn, loader) + + +@pytest.fixture +def temp_phplib_dir_with_migration(src_dir, tmp_path): + """ + Return temporary phpdir with migration subdirectory and + PhraseSettingsToJson.php script inside. + """ + migration_file = (src_dir / 'lib-php' / 'migration' / 'PhraseSettingsToJson.php').resolve() + + phpdir = tmp_path / 'tempphp' + phpdir.mkdir() + + (phpdir / 'migration').mkdir() + migration_dest_path = (phpdir / 'migration' / 'PhraseSettingsToJson.php').resolve() + copyfile(str(migration_file), str(migration_dest_path)) + + return phpdir + + +@pytest.fixture +def xml_wiki_content(src_dir): + """ + return the content of the static xml test file. + """ + xml_test_content_path = (src_dir / 'test' / 'testdata' / 'special_phrases_test_content.txt').resolve() + return xml_test_content_path.read_text() + + +@pytest.fixture +def default_phrases(table_factory): + table_factory('place_classtype_testclasstypetable_to_delete') + table_factory('place_classtype_testclasstypetable_to_keep') + def test_fetch_existing_place_classtype_tables(sp_importer, table_factory): """ @@ -48,12 +93,12 @@ def test_load_white_and_black_lists(sp_importer): assert isinstance(black_list, dict) and isinstance(white_list, dict) -def test_convert_php_settings(sp_importer): +def test_convert_php_settings(sp_importer, testfile_dir): """ Test that _convert_php_settings_if_needed() convert the given php file to a json file. """ - php_file = (TEST_BASE_DIR / 'testfiles' / 'phrase_settings.php').resolve() + php_file = (testfile_dir / 'phrase_settings.php').resolve() with tempfile.TemporaryDirectory() as temp_dir: temp_settings = (Path(temp_dir) / 'phrase_settings.php').resolve() @@ -70,24 +115,24 @@ def test_convert_settings_wrong_file(sp_importer): with pytest.raises(UsageError, match='random_file is not a valid file.'): sp_importer._convert_php_settings_if_needed('random_file') -def test_convert_settings_json_already_exist(sp_importer): +def test_convert_settings_json_already_exist(sp_importer, testfile_dir): """ Test that if we give to '_convert_php_settings_if_needed' a php file path and that a the corresponding json file already exists, it is returned. """ - php_file = (TEST_BASE_DIR / 'testfiles' / 'phrase_settings.php').resolve() - json_file = (TEST_BASE_DIR / 'testfiles' / 'phrase_settings.json').resolve() + php_file = (testfile_dir / 'phrase_settings.php').resolve() + json_file = (testfile_dir / 'phrase_settings.json').resolve() returned = sp_importer._convert_php_settings_if_needed(php_file) assert returned == json_file -def test_convert_settings_giving_json(sp_importer): +def test_convert_settings_giving_json(sp_importer, testfile_dir): """ Test that if we give to '_convert_php_settings_if_needed' a json file path the same path is directly returned """ - json_file = (TEST_BASE_DIR / 'testfiles' / 'phrase_settings.json').resolve() + json_file = (testfile_dir / 'phrase_settings.json').resolve() returned = sp_importer._convert_php_settings_if_needed(json_file) @@ -186,7 +231,8 @@ def test_remove_non_existent_tables_from_db(sp_importer, default_phrases, @pytest.mark.parametrize("should_replace", [(True), (False)]) def test_import_phrases(monkeypatch, temp_db_conn, def_config, sp_importer, - placex_table, table_factory, tokenizer_mock, should_replace): + placex_table, table_factory, tokenizer_mock, + xml_wiki_content, should_replace): """ Check that the main import_phrases() method is well executed. It should create the place_classtype table, the place_id and centroid indexes, @@ -200,7 +246,7 @@ def test_import_phrases(monkeypatch, temp_db_conn, def_config, sp_importer, table_factory('place_classtype_wrongclass_wrongtype') monkeypatch.setattr('nominatim.tools.special_phrases.sp_wiki_loader.SPWikiLoader._get_wiki_content', - mock_get_wiki_content) + lambda self, lang: xml_wiki_content) tokenizer = tokenizer_mock() sp_importer.import_phrases(tokenizer, should_replace) @@ -221,22 +267,6 @@ def test_import_phrases(monkeypatch, temp_db_conn, def_config, sp_importer, if should_replace: assert not temp_db_conn.table_exists('place_classtype_wrongclass_wrongtype') - -def mock_get_wiki_content(self, lang): - """ - Mock the _get_wiki_content() method to return - static xml test file content. - """ - return get_test_xml_wiki_content() - -def get_test_xml_wiki_content(): - """ - return the content of the static xml test file. - """ - xml_test_content_path = (TEST_BASE_DIR / 'testdata' / 'special_phrases_test_content.txt').resolve() - with open(xml_test_content_path) as xml_content_reader: - return xml_content_reader.read() - def check_table_exist(temp_db_conn, phrase_class, phrase_type): """ Verify that the place_classtype table exists for the given @@ -272,31 +302,3 @@ def check_placeid_and_centroid_indexes(temp_db_conn, phrase_class, phrase_type): and temp_db_conn.index_exists(index_prefix + 'place_id') ) - -@pytest.fixture -def sp_importer(temp_db_conn, def_config, temp_phplib_dir_with_migration): - """ - Return an instance of SPImporter. - """ - loader = SPWikiLoader(def_config, ['en']) - return SPImporter(def_config, temp_phplib_dir_with_migration, temp_db_conn, loader) - -@pytest.fixture -def temp_phplib_dir_with_migration(): - """ - Return temporary phpdir with migration subdirectory and - PhraseSettingsToJson.php script inside. - """ - migration_file = (TEST_BASE_DIR / '..' / 'lib-php' / 'migration' - / 'PhraseSettingsToJson.php').resolve() - with tempfile.TemporaryDirectory() as phpdir: - (Path(phpdir) / 'migration').mkdir() - migration_dest_path = (Path(phpdir) / 'migration' / 'PhraseSettingsToJson.php').resolve() - copyfile(migration_file, migration_dest_path) - - yield Path(phpdir) - -@pytest.fixture -def default_phrases(table_factory): - table_factory('place_classtype_testclasstypetable_to_delete') - table_factory('place_classtype_testclasstypetable_to_keep') diff --git a/test/python/test_tools_refresh.py b/test/python/test_tools_refresh.py index b472ee30..f8428476 100644 --- a/test/python/test_tools_refresh.py +++ b/test/python/test_tools_refresh.py @@ -7,20 +7,18 @@ import pytest from nominatim.tools import refresh -TEST_DIR = (Path(__file__) / '..' / '..').resolve() - def test_refresh_import_wikipedia_not_existing(dsn): assert 1 == refresh.import_wikipedia_articles(dsn, Path('.')) @pytest.mark.parametrize("replace", (True, False)) -def test_refresh_import_wikipedia(dsn, table_factory, temp_db_cursor, replace): +def test_refresh_import_wikipedia(dsn, src_dir, table_factory, temp_db_cursor, replace): if replace: table_factory('wikipedia_article') table_factory('wikipedia_redirect') # use the small wikipedia file for the API testdb - assert 0 == refresh.import_wikipedia_articles(dsn, TEST_DIR / 'testdb') + assert 0 == refresh.import_wikipedia_articles(dsn, src_dir / 'test' / 'testdb') assert temp_db_cursor.table_rows('wikipedia_article') > 0 assert temp_db_cursor.table_rows('wikipedia_redirect') > 0 diff --git a/test/python/test_tools_sp_csv_loader.py b/test/python/test_tools_sp_csv_loader.py index ccc9996d..4bf7137e 100644 --- a/test/python/test_tools_sp_csv_loader.py +++ b/test/python/test_tools_sp_csv_loader.py @@ -1,12 +1,10 @@ """ Tests for methods of the SPCsvLoader class. """ -from nominatim.errors import UsageError import pytest -from pathlib import Path -from nominatim.tools.special_phrases.sp_csv_loader import SPCsvLoader -TEST_BASE_DIR = Path(__file__) / '..' / '..' +from nominatim.errors import UsageError +from nominatim.tools.special_phrases.sp_csv_loader import SPCsvLoader def test_parse_csv(sp_csv_loader): """ @@ -49,10 +47,10 @@ def check_phrases_content(phrases): and p.p_operator == '-' for p in phrases) @pytest.fixture -def sp_csv_loader(): +def sp_csv_loader(src_dir): """ Return an instance of SPCsvLoader. """ - csv_path = (TEST_BASE_DIR / 'testdata' / 'sp_csv_test.csv').resolve() + csv_path = (src_dir / 'test' / 'testdata' / 'sp_csv_test.csv').resolve() loader = SPCsvLoader(csv_path) return loader diff --git a/test/python/test_tools_sp_wiki_loader.py b/test/python/test_tools_sp_wiki_loader.py index b4f6d529..83e56ef5 100644 --- a/test/python/test_tools_sp_wiki_loader.py +++ b/test/python/test_tools_sp_wiki_loader.py @@ -2,18 +2,35 @@ Tests for methods of the SPWikiLoader class. """ import pytest -from pathlib import Path from nominatim.tools.special_phrases.sp_wiki_loader import SPWikiLoader -TEST_BASE_DIR = Path(__file__) / '..' / '..' +@pytest.fixture +def xml_wiki_content(src_dir): + """ + return the content of the static xml test file. + """ + xml_test_content_path = (src_dir / 'test' / 'testdata' / 'special_phrases_test_content.txt').resolve() + with open(xml_test_content_path) as xml_content_reader: + return xml_content_reader.read() -def test_parse_xml(sp_wiki_loader): + +@pytest.fixture +def sp_wiki_loader(monkeypatch, def_config, xml_wiki_content): + """ + Return an instance of SPWikiLoader. + """ + loader = SPWikiLoader(def_config, ['en']) + monkeypatch.setattr('nominatim.tools.special_phrases.sp_wiki_loader.SPWikiLoader._get_wiki_content', + lambda self, lang: xml_wiki_content) + return loader + + +def test_parse_xml(sp_wiki_loader, xml_wiki_content): """ Test method parse_xml() Should return the right SpecialPhrase objects. """ - xml = get_test_xml_wiki_content() - phrases = sp_wiki_loader.parse_xml(xml) + phrases = sp_wiki_loader.parse_xml(xml_wiki_content) assert check_phrases_content(phrases) @@ -37,27 +54,3 @@ def check_phrases_content(phrases): and any(p.p_label == 'Zip Line' and p.p_class == 'aerialway' and p.p_type == 'zip_line' and p.p_operator == '-' for p in phrases) -@pytest.fixture -def sp_wiki_loader(monkeypatch, def_config): - """ - Return an instance of SPWikiLoader. - """ - loader = SPWikiLoader(def_config, ['en']) - monkeypatch.setattr('nominatim.tools.special_phrases.sp_wiki_loader.SPWikiLoader._get_wiki_content', - mock_get_wiki_content) - return loader - -def mock_get_wiki_content(self, lang): - """ - Mock the _get_wiki_content() method to return - static xml test file content. - """ - return get_test_xml_wiki_content() - -def get_test_xml_wiki_content(): - """ - return the content of the static xml test file. - """ - xml_test_content_path = (TEST_BASE_DIR / 'testdata' / 'special_phrases_test_content.txt').resolve() - with open(xml_test_content_path) as xml_content_reader: - return xml_content_reader.read()