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