test/bdd/environment.py

   1 from behave import *
   2 import logging
   3 import os
   4 import psycopg2
   5 import psycopg2.extras
   6 import subprocess
   7 import tempfile
   8
   9 logger = logging.getLogger(__name__)
  10
  11 userconfig = {
  12     'BUILDDIR' : os.path.join(os.path.split(__file__)[0], "../../build"),
  13     'REMOVE_TEMPLATE' : False,
  14     'KEEP_TEST_DB' : False,
  15     'DB_HOST' : None,
  16     'DB_PORT' : None,
  17     'DB_USER' : None,
  18     'DB_PASS' : None,
  19     'TEMPLATE_DB' : 'test_template_nominatim',
  20     'TEST_DB' : 'test_nominatim',
  21     'API_TEST_DB' : 'test_api_nominatim',
  22     'SERVER_MODULE_PATH' : None,
  23     'PHPCOV' : False, # set to output directory to enable code coverage
  24 }
  25
  26 use_step_matcher("re")
  27
  28
  29 class NominatimEnvironment(object):
  30     """ Collects all functions for the execution of Nominatim functions.
  31     """
  32
  33     def __init__(self, config):
  34         self.build_dir = os.path.abspath(config['BUILDDIR'])
  35         self.src_dir = os.path.abspath(os.path.join(os.path.split(__file__)[0], "../.."))
  36         self.db_host = config['DB_HOST']
  37         self.db_port = config['DB_PORT']
  38         self.db_user = config['DB_USER']
  39         self.db_pass = config['DB_PASS']
  40         self.template_db = config['TEMPLATE_DB']
  41         self.test_db = config['TEST_DB']
  42         self.api_test_db = config['API_TEST_DB']
  43         self.server_module_path = config['SERVER_MODULE_PATH']
  44         self.reuse_template = not config['REMOVE_TEMPLATE']
  45         self.keep_scenario_db = config['KEEP_TEST_DB']
  46         self.code_coverage_path = config['PHPCOV']
  47         self.code_coverage_id = 1
  48         self.test_env = None
  49
  50         self.template_db_done = False
  51         self.website_dir = None
  52
  53     def connect_database(self, dbname):
  54         dbargs = {'database': dbname}
  55         if self.db_host:
  56             dbargs['host'] = self.db_host
  57         if self.db_port:
  58             dbargs['port'] = self.db_port
  59         if self.db_user:
  60             dbargs['user'] = self.db_user
  61         if self.db_pass:
  62             dbargs['password'] = self.db_pass
  63         conn = psycopg2.connect(**dbargs)
  64         return conn
  65
  66     def next_code_coverage_file(self):
  67         fn = os.path.join(self.code_coverage_path, "%06d.cov" % self.code_coverage_id)
  68         self.code_coverage_id += 1
  69
  70         return fn
  71
  72     def write_nominatim_config(self, dbname):
  73         dsn = 'pgsql:dbname={}{}{}{}{}'.format(
  74                 dbname,
  75                  (';host=' + self.db_host) if self.db_host else '',
  76                  (';port=' + self.db_port) if self.db_port else '',
  77                  (';user=' + self.db_user) if self.db_user else '',
  78                  (';password=' + self.db_pass) if self.db_pass else ''
  79                  )
  80
  81         if self.website_dir is not None \
  82            and self.test_env is not None \
  83            and dsn == self.test_env['NOMINATIM_DATABASE_DSN']:
  84             return # environment already set uo
  85
  86         self.test_env = os.environ
  87         self.test_env['NOMINATIM_DATABASE_DSN'] = dsn
  88         self.test_env['NOMINATIM_FLATNODE_FILE'] = ''
  89         self.test_env['NOMINATIM_IMPORT_STYLE'] = 'full'
  90         self.test_env['NOMINATIM_USE_US_TIGER_DATA'] = 'yes'
  91
  92         if self.website_dir is not None:
  93             self.website_dir.cleanup()
  94
  95         self.website_dir = tempfile.TemporaryDirectory()
  96         self.run_setup_script('setup-website')
  97
  98
  99     def db_drop_database(self, name):
 100         conn = self.connect_database('postgres')
 101         conn.set_isolation_level(0)
 102         cur = conn.cursor()
 103         cur.execute('DROP DATABASE IF EXISTS %s' % (name, ))
 104         conn.close()
 105
 106     def setup_template_db(self):
 107         if self.template_db_done:
 108             return
 109
 110         self.template_db_done = True
 111
 112         if self.reuse_template:
 113             # check that the template is there
 114             conn = self.connect_database('postgres')
 115             cur = conn.cursor()
 116             cur.execute('select count(*) from pg_database where datname = %s',
 117                         (self.template_db,))
 118             if cur.fetchone()[0] == 1:
 119                 return
 120             conn.close()
 121         else:
 122             # just in case... make sure a previous table has been dropped
 123             self.db_drop_database(self.template_db)
 124
 125         try:
 126             # call the first part of database setup
 127             self.write_nominatim_config(self.template_db)
 128             self.run_setup_script('create-db', 'setup-db')
 129             # remove external data to speed up indexing for tests
 130             conn = self.connect_database(self.template_db)
 131             cur = conn.cursor()
 132             cur.execute("""select tablename from pg_tables
 133                            where tablename in ('gb_postcode', 'us_postcode')""")
 134             for t in cur:
 135                 conn.cursor().execute('TRUNCATE TABLE %s' % (t[0],))
 136             conn.commit()
 137             conn.close()
 138
 139             # execute osm2pgsql import on an empty file to get the right tables
 140             with tempfile.NamedTemporaryFile(dir='/tmp', suffix='.xml') as fd:
 141                 fd.write(b'<osm version="0.6"></osm>')
 142                 fd.flush()
 143                 self.run_setup_script('import-data',
 144                                       'ignore-errors',
 145                                       'create-functions',
 146                                       'create-tables',
 147                                       'create-partition-tables',
 148                                       'create-partition-functions',
 149                                       'load-data',
 150                                       'create-search-indices',
 151                                       osm_file=fd.name,
 152                                       osm2pgsql_cache='200')
 153         except:
 154             self.db_drop_database(self.template_db)
 155             raise
 156
 157
 158     def setup_api_db(self, context):
 159         self.write_nominatim_config(self.api_test_db)
 160
 161     def setup_unknown_db(self, context):
 162         self.write_nominatim_config('UNKNOWN_DATABASE_NAME')
 163
 164     def setup_db(self, context):
 165         self.setup_template_db()
 166         self.write_nominatim_config(self.test_db)
 167         conn = self.connect_database(self.template_db)
 168         conn.set_isolation_level(0)
 169         cur = conn.cursor()
 170         cur.execute('DROP DATABASE IF EXISTS %s' % (self.test_db, ))
 171         cur.execute('CREATE DATABASE %s TEMPLATE = %s' % (self.test_db, self.template_db))
 172         conn.close()
 173         context.db = self.connect_database(self.test_db)
 174         psycopg2.extras.register_hstore(context.db, globally=False)
 175
 176     def teardown_db(self, context):
 177         if 'db' in context:
 178             context.db.close()
 179
 180         if not self.keep_scenario_db:
 181             self.db_drop_database(self.test_db)
 182
 183     def run_setup_script(self, *args, **kwargs):
 184         if self.server_module_path:
 185             kwargs = dict(kwargs)
 186             kwargs['module_path'] = self.server_module_path
 187         self.run_nominatim_script('setup', *args, **kwargs)
 188
 189     def run_update_script(self, *args, **kwargs):
 190         self.run_nominatim_script('update', *args, **kwargs)
 191
 192     def run_nominatim_script(self, script, *args, **kwargs):
 193         cmd = ['/usr/bin/env', 'php', '-Cq']
 194         cmd.append(os.path.join(self.build_dir, 'utils', '%s.php' % script))
 195         cmd.extend(['--%s' % x for x in args])
 196         for k, v in kwargs.items():
 197             cmd.extend(('--' + k.replace('_', '-'), str(v)))
 198
 199         if self.website_dir is not None:
 200             cwd = self.website_dir.name
 201         else:
 202             cwd = self.build_dir
 203
 204         proc = subprocess.Popen(cmd, cwd=cwd, env=self.test_env,
 205                                 stdout=subprocess.PIPE, stderr=subprocess.PIPE)
 206         (outp, outerr) = proc.communicate()
 207         outerr = outerr.decode('utf-8').replace('\\n', '\n')
 208         logger.debug("run_nominatim_script: %s\n%s\n%s" % (cmd, outp, outerr))
 209         assert (proc.returncode == 0), "Script '%s' failed:\n%s\n%s\n" % (script, outp, outerr)
 210
 211
 212 class OSMDataFactory(object):
 213
 214     def __init__(self):
 215         scriptpath = os.path.dirname(os.path.abspath(__file__))
 216         self.scene_path = os.environ.get('SCENE_PATH',
 217                            os.path.join(scriptpath, '..', 'scenes', 'data'))
 218         self.scene_cache = {}
 219         self.clear_grid()
 220
 221     def parse_geometry(self, geom, scene):
 222         if geom.find(':') >= 0:
 223             return "ST_SetSRID(%s, 4326)" % self.get_scene_geometry(scene, geom)
 224
 225         if geom.find(',') < 0:
 226             out = "POINT(%s)" % self.mk_wkt_point(geom)
 227         elif geom.find('(') < 0:
 228             line = ','.join([self.mk_wkt_point(x) for x in geom.split(',')])
 229             out = "LINESTRING(%s)" % line
 230         else:
 231             inner = geom.strip('() ')
 232             line = ','.join([self.mk_wkt_point(x) for x in inner.split(',')])
 233             out = "POLYGON((%s))" % line
 234
 235         return "ST_SetSRID('%s'::geometry, 4326)" % out
 236
 237     def mk_wkt_point(self, point):
 238         geom = point.strip()
 239         if geom.find(' ') >= 0:
 240             return geom
 241         else:
 242             pt = self.grid_node(int(geom))
 243             assert pt is not None, "Bad scenario: Point '{}' not found in grid".format(geom)
 244             return "%f %f" % pt
 245
 246     def get_scene_geometry(self, default_scene, name):
 247         geoms = []
 248         for obj in name.split('+'):
 249             oname = obj.strip()
 250             if oname.startswith(':'):
 251                 assert default_scene is not None, "Bad scenario: You need to set a scene"
 252                 defscene = self.load_scene(default_scene)
 253                 wkt = defscene[oname[1:]]
 254             else:
 255                 scene, obj = oname.split(':', 2)
 256                 scene_geoms = self.load_scene(scene)
 257                 wkt = scene_geoms[obj]
 258
 259             geoms.append("'%s'::geometry" % wkt)
 260
 261         if len(geoms) == 1:
 262             return geoms[0]
 263         else:
 264             return 'ST_LineMerge(ST_Collect(ARRAY[%s]))' % ','.join(geoms)
 265
 266     def load_scene(self, name):
 267         if name in self.scene_cache:
 268             return self.scene_cache[name]
 269
 270         scene = {}
 271         with open(os.path.join(self.scene_path, "%s.wkt" % name), 'r') as fd:
 272             for line in fd:
 273                 if line.strip():
 274                     obj, wkt = line.split('|', 2)
 275                     scene[obj.strip()] = wkt.strip()
 276             self.scene_cache[name] = scene
 277
 278         return scene
 279
 280     def clear_grid(self):
 281         self.grid = {}
 282
 283     def add_grid_node(self, nodeid, x, y):
 284         self.grid[nodeid] = (x, y)
 285
 286     def grid_node(self, nodeid):
 287         return self.grid.get(nodeid)
 288
 289
 290 def before_all(context):
 291     # logging setup
 292     context.config.setup_logging()
 293     # set up -D options
 294     for k,v in userconfig.items():
 295         context.config.userdata.setdefault(k, v)
 296     logging.debug('User config: %s' %(str(context.config.userdata)))
 297     # Nominatim test setup
 298     context.nominatim = NominatimEnvironment(context.config.userdata)
 299     context.osm = OSMDataFactory()
 300
 301
 302 def before_scenario(context, scenario):
 303     if 'DB' in context.tags:
 304         context.nominatim.setup_db(context)
 305     elif 'APIDB' in context.tags:
 306         context.nominatim.setup_api_db(context)
 307     elif 'UNKNOWNDB' in context.tags:
 308         context.nominatim.setup_unknown_db(context)
 309     context.scene = None
 310
 311 def after_scenario(context, scenario):
 312     if 'DB' in context.tags:
 313         context.nominatim.teardown_db(context)