test/bdd/steps/nominatim_environment.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 from pathlib import Path
   8 import sys
   9 import tempfile
  10
  11 import psycopg2
  12 import psycopg2.extras
  13
  14 sys.path.insert(1, str((Path(__file__) / '..' / '..' / '..' / '..').resolve()))
  15
  16 from nominatim import cli
  17 from nominatim.config import Configuration
  18 from nominatim.db.connection import Connection
  19 from nominatim.tools import refresh
  20 from nominatim.tokenizer import factory as tokenizer_factory
  21 from steps.utils import run_script
  22
  23 class NominatimEnvironment:
  24     """ Collects all functions for the execution of Nominatim functions.
  25     """
  26
  27     def __init__(self, config):
  28         self.build_dir = Path(config['BUILDDIR']).resolve()
  29         self.src_dir = (Path(__file__) / '..' / '..' / '..' / '..').resolve()
  30         self.db_host = config['DB_HOST']
  31         self.db_port = config['DB_PORT']
  32         self.db_user = config['DB_USER']
  33         self.db_pass = config['DB_PASS']
  34         self.template_db = config['TEMPLATE_DB']
  35         self.test_db = config['TEST_DB']
  36         self.api_test_db = config['API_TEST_DB']
  37         self.api_test_file = config['API_TEST_FILE']
  38         self.tokenizer = config['TOKENIZER']
  39         self.import_style = config['STYLE']
  40         self.server_module_path = config['SERVER_MODULE_PATH']
  41         self.reuse_template = not config['REMOVE_TEMPLATE']
  42         self.keep_scenario_db = config['KEEP_TEST_DB']
  43         self.code_coverage_path = config['PHPCOV']
  44         self.code_coverage_id = 1
  45
  46         self.default_config = Configuration(None, self.src_dir / 'settings').get_os_env()
  47         self.test_env = None
  48         self.template_db_done = False
  49         self.api_db_done = False
  50         self.website_dir = None
  51
  52     def connect_database(self, dbname):
  53         """ Return a connection to the database with the given name.
  54             Uses configured host, user and port.
  55         """
  56         dbargs = {'database': dbname}
  57         if self.db_host:
  58             dbargs['host'] = self.db_host
  59         if self.db_port:
  60             dbargs['port'] = self.db_port
  61         if self.db_user:
  62             dbargs['user'] = self.db_user
  63         if self.db_pass:
  64             dbargs['password'] = self.db_pass
  65         conn = psycopg2.connect(connection_factory=Connection, **dbargs)
  66         return conn
  67
  68     def next_code_coverage_file(self):
  69         """ Generate the next name for a coverage file.
  70         """
  71         fn = Path(self.code_coverage_path) / "{:06d}.cov".format(self.code_coverage_id)
  72         self.code_coverage_id += 1
  73
  74         return fn.resolve()
  75
  76     def write_nominatim_config(self, dbname):
  77         """ Set up a custom test configuration that connects to the given
  78             database. This sets up the environment variables so that they can
  79             be picked up by dotenv and creates a project directory with the
  80             appropriate website scripts.
  81         """
  82         dsn = 'pgsql:dbname={}'.format(dbname)
  83         if self.db_host:
  84             dsn += ';host=' + self.db_host
  85         if self.db_port:
  86             dsn += ';port=' + self.db_port
  87         if self.db_user:
  88             dsn += ';user=' + self.db_user
  89         if self.db_pass:
  90             dsn += ';password=' + self.db_pass
  91
  92         if self.website_dir is not None \
  93            and self.test_env is not None \
  94            and dsn == self.test_env['NOMINATIM_DATABASE_DSN']:
  95             return # environment already set uo
  96
  97         self.test_env = dict(self.default_config)
  98         self.test_env['NOMINATIM_DATABASE_DSN'] = dsn
  99         self.test_env['NOMINATIM_LANGUAGES'] = 'en,de,fr,ja'
 100         self.test_env['NOMINATIM_FLATNODE_FILE'] = ''
 101         self.test_env['NOMINATIM_IMPORT_STYLE'] = 'full'
 102         self.test_env['NOMINATIM_USE_US_TIGER_DATA'] = 'yes'
 103         self.test_env['NOMINATIM_DATADIR'] = str((self.src_dir / 'data').resolve())
 104         self.test_env['NOMINATIM_SQLDIR'] = str((self.src_dir / 'lib-sql').resolve())
 105         self.test_env['NOMINATIM_CONFIGDIR'] = str((self.src_dir / 'settings').resolve())
 106         self.test_env['NOMINATIM_DATABASE_MODULE_SRC_PATH'] = str((self.build_dir / 'module').resolve())
 107         self.test_env['NOMINATIM_OSM2PGSQL_BINARY'] = str((self.build_dir / 'osm2pgsql' / 'osm2pgsql').resolve())
 108         self.test_env['NOMINATIM_NOMINATIM_TOOL'] = str((self.build_dir / 'nominatim').resolve())
 109         if self.tokenizer is not None:
 110             self.test_env['NOMINATIM_TOKENIZER'] = self.tokenizer
 111         if self.import_style is not None:
 112             self.test_env['NOMINATIM_IMPORT_STYLE'] = self.import_style
 113
 114         if self.server_module_path:
 115             self.test_env['NOMINATIM_DATABASE_MODULE_PATH'] = self.server_module_path
 116         else:
 117             # avoid module being copied into the temporary environment
 118             self.test_env['NOMINATIM_DATABASE_MODULE_PATH'] = str((self.build_dir / 'module').resolve())
 119
 120         if self.website_dir is not None:
 121             self.website_dir.cleanup()
 122
 123         self.website_dir = tempfile.TemporaryDirectory()
 124
 125         try:
 126             conn = self.connect_database(dbname)
 127         except:
 128             conn = False
 129         refresh.setup_website(Path(self.website_dir.name) / 'website',
 130                               self.get_test_config(), conn)
 131
 132
 133     def get_test_config(self):
 134         cfg = Configuration(Path(self.website_dir.name), self.src_dir / 'settings',
 135                             environ=self.test_env)
 136         cfg.set_libdirs(module=self.build_dir / 'module',
 137                         osm2pgsql=self.build_dir / 'osm2pgsql' / 'osm2pgsql',
 138                         php=self.src_dir / 'lib-php',
 139                         sql=self.src_dir / 'lib-sql',
 140                         data=self.src_dir / 'data')
 141         return cfg
 142
 143     def get_libpq_dsn(self):
 144         dsn = self.test_env['NOMINATIM_DATABASE_DSN']
 145
 146         def quote_param(param):
 147             key, val = param.split('=')
 148             val = val.replace('\\', '\\\\').replace("'", "\\'")
 149             if ' ' in val:
 150                 val = "'" + val + "'"
 151             return key + '=' + val
 152
 153         if dsn.startswith('pgsql:'):
 154             # Old PHP DSN format. Convert before returning.
 155             return ' '.join([quote_param(p) for p in dsn[6:].split(';')])
 156
 157         return dsn
 158
 159
 160     def db_drop_database(self, name):
 161         """ Drop the database with the given name.
 162         """
 163         conn = self.connect_database('postgres')
 164         conn.set_isolation_level(0)
 165         cur = conn.cursor()
 166         cur.execute('DROP DATABASE IF EXISTS {}'.format(name))
 167         conn.close()
 168
 169     def setup_template_db(self):
 170         """ Setup a template database that already contains common test data.
 171             Having a template database speeds up tests considerably but at
 172             the price that the tests sometimes run with stale data.
 173         """
 174         if self.template_db_done:
 175             return
 176
 177         self.template_db_done = True
 178
 179         self.write_nominatim_config(self.template_db)
 180
 181         if not self._reuse_or_drop_db(self.template_db):
 182             try:
 183                 # execute nominatim import on an empty file to get the right tables
 184                 with tempfile.NamedTemporaryFile(dir='/tmp', suffix='.xml') as fd:
 185                     fd.write(b'<osm version="0.6"></osm>')
 186                     fd.flush()
 187                     self.run_nominatim('import', '--osm-file', fd.name,
 188                                                  '--osm2pgsql-cache', '1',
 189                                                  '--ignore-errors',
 190                                                  '--offline', '--index-noanalyse')
 191             except:
 192                 self.db_drop_database(self.template_db)
 193                 raise
 194
 195         self.run_nominatim('refresh', '--functions')
 196
 197
 198     def setup_api_db(self):
 199         """ Setup a test against the API test database.
 200         """
 201         self.write_nominatim_config(self.api_test_db)
 202
 203         if not self.api_db_done:
 204             self.api_db_done = True
 205
 206             if not self._reuse_or_drop_db(self.api_test_db):
 207                 testdata = (Path(__file__) / '..' / '..' / '..' / 'testdb').resolve()
 208                 self.test_env['NOMINATIM_WIKIPEDIA_DATA_PATH'] = str(testdata)
 209                 simp_file = Path(self.website_dir.name) / 'secondary_importance.sql.gz'
 210                 simp_file.symlink_to(testdata / 'secondary_importance.sql.gz')
 211
 212                 try:
 213                     self.run_nominatim('import', '--osm-file', str(self.api_test_file))
 214                     self.run_nominatim('add-data', '--tiger-data', str(testdata / 'tiger'))
 215                     self.run_nominatim('freeze')
 216
 217                     if self.tokenizer == 'legacy':
 218                         phrase_file = str(testdata / 'specialphrases_testdb.sql')
 219                         run_script(['psql', '-d', self.api_test_db, '-f', phrase_file])
 220                     else:
 221                         csv_path = str(testdata / 'full_en_phrases_test.csv')
 222                         self.run_nominatim('special-phrases', '--import-from-csv', csv_path)
 223                 except:
 224                     self.db_drop_database(self.api_test_db)
 225                     raise
 226
 227         tokenizer_factory.get_tokenizer_for_db(self.get_test_config())
 228
 229
 230     def setup_unknown_db(self):
 231         """ Setup a test against a non-existing database.
 232         """
 233         # The tokenizer needs an existing database to function.
 234         # So start with the usual database
 235         class _Context:
 236             db = None
 237
 238         context = _Context()
 239         self.setup_db(context)
 240         tokenizer_factory.create_tokenizer(self.get_test_config(), init_db=False)
 241
 242         # Then drop the DB again
 243         self.teardown_db(context, force_drop=True)
 244
 245     def setup_db(self, context):
 246         """ Setup a test against a fresh, empty test database.
 247         """
 248         self.setup_template_db()
 249         conn = self.connect_database(self.template_db)
 250         conn.set_isolation_level(0)
 251         cur = conn.cursor()
 252         cur.execute('DROP DATABASE IF EXISTS {}'.format(self.test_db))
 253         cur.execute('CREATE DATABASE {} TEMPLATE = {}'.format(self.test_db, self.template_db))
 254         conn.close()
 255         self.write_nominatim_config(self.test_db)
 256         context.db = self.connect_database(self.test_db)
 257         context.db.autocommit = True
 258         psycopg2.extras.register_hstore(context.db, globally=False)
 259
 260     def teardown_db(self, context, force_drop=False):
 261         """ Remove the test database, if it exists.
 262         """
 263         if hasattr(context, 'db'):
 264             context.db.close()
 265
 266         if force_drop or not self.keep_scenario_db:
 267             self.db_drop_database(self.test_db)
 268
 269     def _reuse_or_drop_db(self, name):
 270         """ Check for the existance of the given DB. If reuse is enabled,
 271             then the function checks for existance and returns True if the
 272             database is already there. Otherwise an existing database is
 273             dropped and always false returned.
 274         """
 275         if self.reuse_template:
 276             conn = self.connect_database('postgres')
 277             with conn.cursor() as cur:
 278                 cur.execute('select count(*) from pg_database where datname = %s',
 279                             (name,))
 280                 if cur.fetchone()[0] == 1:
 281                     return True
 282             conn.close()
 283         else:
 284             self.db_drop_database(name)
 285
 286         return False
 287
 288     def reindex_placex(self, db):
 289         """ Run the indexing step until all data in the placex has
 290             been processed. Indexing during updates can produce more data
 291             to index under some circumstances. That is why indexing may have
 292             to be run multiple times.
 293         """
 294         with db.cursor() as cur:
 295             while True:
 296                 self.run_nominatim('index')
 297
 298                 cur.execute("SELECT 'a' FROM placex WHERE indexed_status != 0 LIMIT 1")
 299                 if cur.rowcount == 0:
 300                     return
 301
 302     def run_nominatim(self, *cmdline):
 303         """ Run the nominatim command-line tool via the library.
 304         """
 305         if self.website_dir is not None:
 306             cmdline = list(cmdline) + ['--project-dir', self.website_dir.name]
 307
 308         cli.nominatim(module_dir='',
 309                       osm2pgsql_path=str(self.build_dir / 'osm2pgsql' / 'osm2pgsql'),
 310                       phplib_dir=str(self.src_dir / 'lib-php'),
 311                       sqllib_dir=str(self.src_dir / 'lib-sql'),
 312                       data_dir=str(self.src_dir / 'data'),
 313                       config_dir=str(self.src_dir / 'settings'),
 314                       cli_args=cmdline,
 315                       phpcgi_path='',
 316                       environ=self.test_env)
 317
 318
 319     def copy_from_place(self, db):
 320         """ Copy data from place to the placex and location_property_osmline
 321             tables invoking the appropriate triggers.
 322         """
 323         self.run_nominatim('refresh', '--functions', '--no-diff-updates')
 324
 325         with db.cursor() as cur:
 326             cur.execute("""INSERT INTO placex (osm_type, osm_id, class, type,
 327                                                name, admin_level, address,
 328                                                extratags, geometry)
 329                              SELECT osm_type, osm_id, class, type,
 330                                     name, admin_level, address,
 331                                     extratags, geometry
 332                                FROM place
 333                                WHERE not (class='place' and type='houses' and osm_type='W')""")
 334             cur.execute("""INSERT INTO location_property_osmline (osm_id, address, linegeo)
 335                              SELECT osm_id, address, geometry
 336                                FROM place
 337                               WHERE class='place' and type='houses'
 338                                     and osm_type='W'
 339                                     and ST_GeometryType(geometry) = 'ST_LineString'""")