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