test/python/api/test_server_glue_v1.py

   1 # SPDX-License-Identifier: GPL-3.0-or-later
   2 #
   3 # This file is part of Nominatim. (https://nominatim.org)
   4 #
   5 # Copyright (C) 2024 by the Nominatim developer community.
   6 # For a full list of authors see the git log.
   7 """
   8 Tests for the Python web frameworks adaptor, v1 API.
   9 """
  10 import json
  11 import xml.etree.ElementTree as ET
  12
  13 import pytest
  14
  15 from fake_adaptor import FakeAdaptor, FakeError, FakeResponse
  16
  17 import nominatim_api.v1.server_glue as glue
  18 import nominatim_api as napi
  19 import nominatim_api.logging as loglib
  20
  21
  22 # ASGIAdaptor.get_int/bool()
  23
  24 @pytest.mark.parametrize('func', ['get_int', 'get_bool'])
  25 def test_adaptor_get_int_missing_but_required(func):
  26     with pytest.raises(FakeError, match='^400 -- .*missing'):
  27         getattr(FakeAdaptor(), func)('something')
  28
  29
  30 @pytest.mark.parametrize('func, val', [('get_int', 23), ('get_bool', True)])
  31 def test_adaptor_get_int_missing_with_default(func, val):
  32     assert getattr(FakeAdaptor(), func)('something', val) == val
  33
  34
  35 @pytest.mark.parametrize('inp', ['0', '234', '-4566953498567934876'])
  36 def test_adaptor_get_int_success(inp):
  37     assert FakeAdaptor(params={'foo': inp}).get_int('foo') == int(inp)
  38     assert FakeAdaptor(params={'foo': inp}).get_int('foo', 4) == int(inp)
  39
  40
  41 @pytest.mark.parametrize('inp', ['rs', '4.5', '6f'])
  42 def test_adaptor_get_int_bad_number(inp):
  43     with pytest.raises(FakeError, match='^400 -- .*must be a number'):
  44         FakeAdaptor(params={'foo': inp}).get_int('foo')
  45
  46
  47 @pytest.mark.parametrize('inp', ['1', 'true', 'whatever', 'false'])
  48 def test_adaptor_get_bool_trueish(inp):
  49     assert FakeAdaptor(params={'foo': inp}).get_bool('foo')
  50
  51
  52 def test_adaptor_get_bool_falsish():
  53     assert not FakeAdaptor(params={'foo': '0'}).get_bool('foo')
  54
  55
  56 # ASGIAdaptor.parse_format()
  57
  58 def test_adaptor_parse_format_use_default():
  59     adaptor = FakeAdaptor()
  60
  61     assert glue.parse_format(adaptor, napi.StatusResult, 'text') == 'text'
  62     assert adaptor.content_type == 'text/plain; charset=utf-8'
  63
  64
  65 def test_adaptor_parse_format_use_configured():
  66     adaptor = FakeAdaptor(params={'format': 'json'})
  67
  68     assert glue.parse_format(adaptor, napi.StatusResult, 'text') == 'json'
  69     assert adaptor.content_type == 'application/json; charset=utf-8'
  70
  71
  72 def test_adaptor_parse_format_invalid_value():
  73     adaptor = FakeAdaptor(params={'format': '@!#'})
  74
  75     with pytest.raises(FakeError, match='^400 -- .*must be one of'):
  76         glue.parse_format(adaptor, napi.StatusResult, 'text')
  77
  78
  79 # ASGIAdaptor.get_accepted_languages()
  80
  81 def test_accepted_languages_from_param():
  82     a = FakeAdaptor(params={'accept-language': 'de'})
  83     assert glue.get_accepted_languages(a) == 'de'
  84
  85
  86 def test_accepted_languages_from_header():
  87     a = FakeAdaptor(headers={'accept-language': 'de'})
  88     assert glue.get_accepted_languages(a) == 'de'
  89
  90
  91 def test_accepted_languages_from_default(monkeypatch):
  92     monkeypatch.setenv('NOMINATIM_DEFAULT_LANGUAGE', 'de')
  93     a = FakeAdaptor()
  94     assert glue.get_accepted_languages(a) == 'de'
  95
  96
  97 def test_accepted_languages_param_over_header():
  98     a = FakeAdaptor(params={'accept-language': 'de'},
  99                     headers={'accept-language': 'en'})
 100     assert glue.get_accepted_languages(a) == 'de'
 101
 102
 103 def test_accepted_languages_header_over_default(monkeypatch):
 104     monkeypatch.setenv('NOMINATIM_DEFAULT_LANGUAGE', 'en')
 105     a = FakeAdaptor(headers={'accept-language': 'de'})
 106     assert glue.get_accepted_languages(a) == 'de'
 107
 108
 109 # ASGIAdaptor.raise_error()
 110
 111 class TestAdaptorRaiseError:
 112
 113     @pytest.fixture(autouse=True)
 114     def init_adaptor(self):
 115         self.adaptor = FakeAdaptor()
 116         glue.setup_debugging(self.adaptor)
 117
 118     def run_raise_error(self, msg, status):
 119         with pytest.raises(FakeError) as excinfo:
 120             self.adaptor.raise_error(msg, status=status)
 121
 122         return excinfo.value
 123
 124
 125     def test_without_content_set(self):
 126         err = self.run_raise_error('TEST', 404)
 127
 128         assert self.adaptor.content_type == 'text/plain; charset=utf-8'
 129         assert err.msg == 'ERROR 404: TEST'
 130         assert err.status == 404
 131
 132
 133     def test_json(self):
 134         self.adaptor.content_type = 'application/json; charset=utf-8'
 135
 136         err = self.run_raise_error('TEST', 501)
 137
 138         content = json.loads(err.msg)['error']
 139         assert content['code'] == 501
 140         assert content['message'] == 'TEST'
 141
 142
 143     def test_xml(self):
 144         self.adaptor.content_type = 'text/xml; charset=utf-8'
 145
 146         err = self.run_raise_error('this!', 503)
 147
 148         content = ET.fromstring(err.msg)
 149
 150         assert content.tag == 'error'
 151         assert content.find('code').text == '503'
 152         assert content.find('message').text == 'this!'
 153
 154
 155 def test_raise_error_during_debug():
 156     a = FakeAdaptor(params={'debug': '1'})
 157     glue.setup_debugging(a)
 158     loglib.log().section('Ongoing')
 159
 160     with pytest.raises(FakeError) as excinfo:
 161         a.raise_error('badstate')
 162
 163     content = ET.fromstring(excinfo.value.msg)
 164
 165     assert content.tag == 'html'
 166
 167     assert '>Ongoing<' in excinfo.value.msg
 168     assert 'badstate' in excinfo.value.msg
 169
 170
 171 # ASGIAdaptor.build_response
 172
 173 def test_build_response_without_content_type():
 174     resp = glue.build_response(FakeAdaptor(), 'attention')
 175
 176     assert isinstance(resp, FakeResponse)
 177     assert resp.status == 200
 178     assert resp.output == 'attention'
 179     assert resp.content_type == 'text/plain; charset=utf-8'
 180
 181
 182 def test_build_response_with_status():
 183     a = FakeAdaptor(params={'format': 'json'})
 184     glue.parse_format(a, napi.StatusResult, 'text')
 185
 186     resp = glue.build_response(a, 'stuff\nmore stuff', status=404)
 187
 188     assert isinstance(resp, FakeResponse)
 189     assert resp.status == 404
 190     assert resp.output == 'stuff\nmore stuff'
 191     assert resp.content_type == 'application/json; charset=utf-8'
 192
 193
 194 def test_build_response_jsonp_with_json():
 195     a = FakeAdaptor(params={'format': 'json', 'json_callback': 'test.func'})
 196     glue.parse_format(a, napi.StatusResult, 'text')
 197
 198     resp = glue.build_response(a, '{}')
 199
 200     assert isinstance(resp, FakeResponse)
 201     assert resp.status == 200
 202     assert resp.output == 'test.func({})'
 203     assert resp.content_type == 'application/javascript; charset=utf-8'
 204
 205
 206 def test_build_response_jsonp_without_json():
 207     a = FakeAdaptor(params={'format': 'text', 'json_callback': 'test.func'})
 208     glue.parse_format(a, napi.StatusResult, 'text')
 209
 210     resp = glue.build_response(a, '{}')
 211
 212     assert isinstance(resp, FakeResponse)
 213     assert resp.status == 200
 214     assert resp.output == '{}'
 215     assert resp.content_type == 'text/plain; charset=utf-8'
 216
 217
 218 @pytest.mark.parametrize('param', ['alert(); func', '\\n', '', 'a b'])
 219 def test_build_response_jsonp_bad_format(param):
 220     a = FakeAdaptor(params={'format': 'json', 'json_callback': param})
 221     glue.parse_format(a, napi.StatusResult, 'text')
 222
 223     with pytest.raises(FakeError, match='^400 -- .*Invalid'):
 224         glue.build_response(a, '{}')
 225
 226
 227 # status_endpoint()
 228
 229 class TestStatusEndpoint:
 230
 231     @pytest.fixture(autouse=True)
 232     def patch_status_func(self, monkeypatch):
 233         async def _status(*args, **kwargs):
 234             return self.status
 235
 236         monkeypatch.setattr(napi.NominatimAPIAsync, 'status', _status)
 237
 238
 239     @pytest.mark.asyncio
 240     async def test_status_without_params(self):
 241         a = FakeAdaptor()
 242         self.status = napi.StatusResult(0, 'foo')
 243
 244         resp = await glue.status_endpoint(napi.NominatimAPIAsync(), a)
 245
 246         assert isinstance(resp, FakeResponse)
 247         assert resp.status == 200
 248         assert resp.content_type == 'text/plain; charset=utf-8'
 249
 250
 251     @pytest.mark.asyncio
 252     async def test_status_with_error(self):
 253         a = FakeAdaptor()
 254         self.status = napi.StatusResult(405, 'foo')
 255
 256         resp = await glue.status_endpoint(napi.NominatimAPIAsync(), a)
 257
 258         assert isinstance(resp, FakeResponse)
 259         assert resp.status == 500
 260         assert resp.content_type == 'text/plain; charset=utf-8'
 261
 262
 263     @pytest.mark.asyncio
 264     async def test_status_json_with_error(self):
 265         a = FakeAdaptor(params={'format': 'json'})
 266         self.status = napi.StatusResult(405, 'foo')
 267
 268         resp = await glue.status_endpoint(napi.NominatimAPIAsync(), a)
 269
 270         assert isinstance(resp, FakeResponse)
 271         assert resp.status == 200
 272         assert resp.content_type == 'application/json; charset=utf-8'
 273
 274
 275     @pytest.mark.asyncio
 276     async def test_status_bad_format(self):
 277         a = FakeAdaptor(params={'format': 'foo'})
 278         self.status = napi.StatusResult(0, 'foo')
 279
 280         with pytest.raises(FakeError):
 281             await glue.status_endpoint(napi.NominatimAPIAsync(), a)
 282
 283
 284 # details_endpoint()
 285
 286 class TestDetailsEndpoint:
 287
 288     @pytest.fixture(autouse=True)
 289     def patch_lookup_func(self, monkeypatch):
 290         self.result = napi.DetailedResult(napi.SourceTable.PLACEX,
 291                                           ('place', 'thing'),
 292                                           napi.Point(1.0, 2.0))
 293         self.lookup_args = []
 294
 295         async def _lookup(*args, **kwargs):
 296             self.lookup_args.extend(args[1:])
 297             return self.result
 298
 299         monkeypatch.setattr(napi.NominatimAPIAsync, 'details', _lookup)
 300
 301
 302     @pytest.mark.asyncio
 303     async def test_details_no_params(self):
 304         a = FakeAdaptor()
 305
 306         with pytest.raises(FakeError, match='^400 -- .*Missing'):
 307             await glue.details_endpoint(napi.NominatimAPIAsync(), a)
 308
 309
 310     @pytest.mark.asyncio
 311     async def test_details_by_place_id(self):
 312         a = FakeAdaptor(params={'place_id': '4573'})
 313
 314         await glue.details_endpoint(napi.NominatimAPIAsync(), a)
 315
 316         assert self.lookup_args[0].place_id == 4573
 317
 318
 319     @pytest.mark.asyncio
 320     async def test_details_by_osm_id(self):
 321         a = FakeAdaptor(params={'osmtype': 'N', 'osmid': '45'})
 322
 323         await glue.details_endpoint(napi.NominatimAPIAsync(), a)
 324
 325         assert self.lookup_args[0].osm_type == 'N'
 326         assert self.lookup_args[0].osm_id == 45
 327         assert self.lookup_args[0].osm_class is None
 328
 329
 330     @pytest.mark.asyncio
 331     async def test_details_with_debugging(self):
 332         a = FakeAdaptor(params={'osmtype': 'N', 'osmid': '45', 'debug': '1'})
 333
 334         resp = await glue.details_endpoint(napi.NominatimAPIAsync(), a)
 335         content = ET.fromstring(resp.output)
 336
 337         assert resp.content_type == 'text/html; charset=utf-8'
 338         assert content.tag == 'html'
 339
 340
 341     @pytest.mark.asyncio
 342     async def test_details_no_result(self):
 343         a = FakeAdaptor(params={'place_id': '4573'})
 344         self.result = None
 345
 346         with pytest.raises(FakeError, match='^404 -- .*found'):
 347             await glue.details_endpoint(napi.NominatimAPIAsync(), a)
 348
 349
 350 # reverse_endpoint()
 351 class TestReverseEndPoint:
 352
 353     @pytest.fixture(autouse=True)
 354     def patch_reverse_func(self, monkeypatch):
 355         self.result = napi.ReverseResult(napi.SourceTable.PLACEX,
 356                                           ('place', 'thing'),
 357                                           napi.Point(1.0, 2.0))
 358         async def _reverse(*args, **kwargs):
 359             return self.result
 360
 361         monkeypatch.setattr(napi.NominatimAPIAsync, 'reverse', _reverse)
 362
 363
 364     @pytest.mark.asyncio
 365     @pytest.mark.parametrize('params', [{}, {'lat': '3.4'}, {'lon': '6.7'}])
 366     async def test_reverse_no_params(self, params):
 367         a = FakeAdaptor()
 368         a.params = params
 369         a.params['format'] = 'xml'
 370
 371         with pytest.raises(FakeError, match='^400 -- (?s:.*)missing'):
 372             await glue.reverse_endpoint(napi.NominatimAPIAsync(), a)
 373
 374
 375     @pytest.mark.asyncio
 376     @pytest.mark.parametrize('params', [{'lat': '45.6', 'lon': '4563'}])
 377     async def test_reverse_success(self, params):
 378         a = FakeAdaptor()
 379         a.params = params
 380         a.params['format'] = 'json'
 381
 382         res = await glue.reverse_endpoint(napi.NominatimAPIAsync(), a)
 383
 384         assert res == ''
 385
 386
 387     @pytest.mark.asyncio
 388     async def test_reverse_success(self):
 389         a = FakeAdaptor()
 390         a.params['lat'] = '56.3'
 391         a.params['lon'] = '6.8'
 392
 393         assert await glue.reverse_endpoint(napi.NominatimAPIAsync(), a)
 394
 395
 396     @pytest.mark.asyncio
 397     async def test_reverse_from_search(self):
 398         a = FakeAdaptor()
 399         a.params['q'] = '34.6 2.56'
 400         a.params['format'] = 'json'
 401
 402         res = await glue.search_endpoint(napi.NominatimAPIAsync(), a)
 403
 404         assert len(json.loads(res.output)) == 1
 405
 406
 407 # lookup_endpoint()
 408
 409 class TestLookupEndpoint:
 410
 411     @pytest.fixture(autouse=True)
 412     def patch_lookup_func(self, monkeypatch):
 413         self.results = [napi.SearchResult(napi.SourceTable.PLACEX,
 414                                           ('place', 'thing'),
 415                                           napi.Point(1.0, 2.0))]
 416         async def _lookup(*args, **kwargs):
 417             return napi.SearchResults(self.results)
 418
 419         monkeypatch.setattr(napi.NominatimAPIAsync, 'lookup', _lookup)
 420
 421
 422     @pytest.mark.asyncio
 423     async def test_lookup_no_params(self):
 424         a = FakeAdaptor()
 425         a.params['format'] = 'json'
 426
 427         res = await glue.lookup_endpoint(napi.NominatimAPIAsync(), a)
 428
 429         assert res.output == '[]'
 430
 431
 432     @pytest.mark.asyncio
 433     @pytest.mark.parametrize('param', ['w', 'bad', ''])
 434     async def test_lookup_bad_params(self, param):
 435         a = FakeAdaptor()
 436         a.params['format'] = 'json'
 437         a.params['osm_ids'] = f'W34,{param},N33333'
 438
 439         res = await glue.lookup_endpoint(napi.NominatimAPIAsync(), a)
 440
 441         assert len(json.loads(res.output)) == 1
 442
 443
 444     @pytest.mark.asyncio
 445     @pytest.mark.parametrize('param', ['p234234', '4563'])
 446     async def test_lookup_bad_osm_type(self, param):
 447         a = FakeAdaptor()
 448         a.params['format'] = 'json'
 449         a.params['osm_ids'] = f'W34,{param},N33333'
 450
 451         res = await glue.lookup_endpoint(napi.NominatimAPIAsync(), a)
 452
 453         assert len(json.loads(res.output)) == 1
 454
 455
 456     @pytest.mark.asyncio
 457     async def test_lookup_working(self):
 458         a = FakeAdaptor()
 459         a.params['format'] = 'json'
 460         a.params['osm_ids'] = 'N23,W34'
 461
 462         res = await glue.lookup_endpoint(napi.NominatimAPIAsync(), a)
 463
 464         assert len(json.loads(res.output)) == 1
 465
 466
 467 # search_endpoint()
 468
 469 class TestSearchEndPointSearch:
 470
 471     @pytest.fixture(autouse=True)
 472     def patch_lookup_func(self, monkeypatch):
 473         self.results = [napi.SearchResult(napi.SourceTable.PLACEX,
 474                                           ('place', 'thing'),
 475                                           napi.Point(1.0, 2.0))]
 476         async def _search(*args, **kwargs):
 477             return napi.SearchResults(self.results)
 478
 479         monkeypatch.setattr(napi.NominatimAPIAsync, 'search', _search)
 480
 481
 482     @pytest.mark.asyncio
 483     async def test_search_free_text(self):
 484         a = FakeAdaptor()
 485         a.params['q'] = 'something'
 486
 487         res = await glue.search_endpoint(napi.NominatimAPIAsync(), a)
 488
 489         assert len(json.loads(res.output)) == 1
 490
 491
 492     @pytest.mark.asyncio
 493     async def test_search_free_text_xml(self):
 494         a = FakeAdaptor()
 495         a.params['q'] = 'something'
 496         a.params['format'] = 'xml'
 497
 498         res = await glue.search_endpoint(napi.NominatimAPIAsync(), a)
 499
 500         assert res.status == 200
 501         assert res.output.index('something') > 0
 502
 503
 504     @pytest.mark.asyncio
 505     async def test_search_free_and_structured(self):
 506         a = FakeAdaptor()
 507         a.params['q'] = 'something'
 508         a.params['city'] = 'ignored'
 509
 510         with pytest.raises(FakeError, match='^400 -- .*cannot be used together'):
 511             res = await glue.search_endpoint(napi.NominatimAPIAsync(), a)
 512
 513
 514     @pytest.mark.asyncio
 515     @pytest.mark.parametrize('dedupe,numres', [(True, 1), (False, 2)])
 516     async def test_search_dedupe(self, dedupe, numres):
 517         self.results = self.results * 2
 518         a = FakeAdaptor()
 519         a.params['q'] = 'something'
 520         if not dedupe:
 521             a.params['dedupe'] = '0'
 522
 523         res = await glue.search_endpoint(napi.NominatimAPIAsync(), a)
 524
 525         assert len(json.loads(res.output)) == numres
 526
 527
 528 class TestSearchEndPointSearchAddress:
 529
 530     @pytest.fixture(autouse=True)
 531     def patch_lookup_func(self, monkeypatch):
 532         self.results = [napi.SearchResult(napi.SourceTable.PLACEX,
 533                                           ('place', 'thing'),
 534                                           napi.Point(1.0, 2.0))]
 535         async def _search(*args, **kwargs):
 536             return napi.SearchResults(self.results)
 537
 538         monkeypatch.setattr(napi.NominatimAPIAsync, 'search_address', _search)
 539
 540
 541     @pytest.mark.asyncio
 542     async def test_search_structured(self):
 543         a = FakeAdaptor()
 544         a.params['street'] = 'something'
 545
 546         res = await glue.search_endpoint(napi.NominatimAPIAsync(), a)
 547
 548         assert len(json.loads(res.output)) == 1
 549
 550
 551 class TestSearchEndPointSearchCategory:
 552
 553     @pytest.fixture(autouse=True)
 554     def patch_lookup_func(self, monkeypatch):
 555         self.results = [napi.SearchResult(napi.SourceTable.PLACEX,
 556                                           ('place', 'thing'),
 557                                           napi.Point(1.0, 2.0))]
 558         async def _search(*args, **kwargs):
 559             return napi.SearchResults(self.results)
 560
 561         monkeypatch.setattr(napi.NominatimAPIAsync, 'search_category', _search)
 562
 563
 564     @pytest.mark.asyncio
 565     async def test_search_category(self):
 566         a = FakeAdaptor()
 567         a.params['q'] = '[shop=fog]'
 568
 569         res = await glue.search_endpoint(napi.NominatimAPIAsync(), a)
 570
 571         assert len(json.loads(res.output)) == 1