test/python/api/search/test_postcode_parser.py

   1
   2 # SPDX-License-Identifier: GPL-3.0-or-later
   3 #
   4 # This file is part of Nominatim. (https://nominatim.org)
   5 #
   6 # Copyright (C) 2025 by the Nominatim developer community.
   7 # For a full list of authors see the git log.
   8 """
   9 Test for parsing of postcodes in queries.
  10 """
  11 import re
  12 from itertools import zip_longest
  13
  14 import pytest
  15
  16 from nominatim_api.search.postcode_parser import PostcodeParser
  17 from nominatim_api.search.query import QueryStruct, PHRASE_ANY, PHRASE_POSTCODE, PHRASE_STREET
  18
  19
  20 @pytest.fixture
  21 def pc_config(project_env):
  22     country_file = project_env.project_dir / 'country_settings.yaml'
  23     country_file.write_text(r"""
  24 ab:
  25   postcode:
  26     pattern: "ddddd ll"
  27 ba:
  28   postcode:
  29     pattern: "ddddd"
  30 de:
  31   postcode:
  32     pattern: "ddddd"
  33 gr:
  34   postcode:
  35     pattern: "(ddd) ?(dd)"
  36     output: \1 \2
  37 in:
  38   postcode:
  39     pattern: "(ddd) ?(ddd)"
  40     output: \1\2
  41 mc:
  42   postcode:
  43     pattern: "980dd"
  44 mz:
  45   postcode:
  46     pattern: "(dddd)(?:-dd)?"
  47 bn:
  48   postcode:
  49     pattern: "(ll) ?(dddd)"
  50     output: \1\2
  51 ky:
  52   postcode:
  53     pattern: "(d)-(dddd)"
  54     output: KY\1-\2
  55     """)
  56
  57     return project_env
  58
  59
  60 def mk_query(inp):
  61     query = QueryStruct([])
  62     phrase_split = re.split(r"([ ,:'-])", inp)
  63
  64     for word, breakchar in zip_longest(*[iter(phrase_split)]*2, fillvalue='>'):
  65         query.add_node(breakchar, PHRASE_ANY, 0.1, word, word)
  66
  67     return query
  68
  69
  70 @pytest.mark.parametrize('query,pos', [('45325 Berlin', 0),
  71                                        ('45325:Berlin', 0),
  72                                        ('45325,Berlin', 0),
  73                                        ('Berlin 45325', 1),
  74                                        ('Berlin,45325', 1),
  75                                        ('Berlin:45325', 1),
  76                                        ('Hansastr,45325 Berlin', 1),
  77                                        ('Hansastr 45325 Berlin', 1)])
  78 def test_simple_postcode(pc_config, query, pos):
  79     parser = PostcodeParser(pc_config)
  80
  81     result = parser.parse(mk_query(query))
  82
  83     assert result == {(pos, pos + 1, '45325'), (pos, pos + 1, '453 25')}
  84
  85
  86 def test_contained_postcode(pc_config):
  87     parser = PostcodeParser(pc_config)
  88
  89     assert parser.parse(mk_query('12345 dx')) == {(0, 1, '12345'), (0, 1, '123 45'),
  90                                                   (0, 2, '12345 DX')}
  91
  92
  93 @pytest.mark.parametrize('query,frm,to', [('345987', 0, 1), ('345 987', 0, 2),
  94                                           ('Aina 345 987', 1, 3),
  95                                           ('Aina 23 345 987 ff', 2, 4)])
  96 def test_postcode_with_space(pc_config, query, frm, to):
  97     parser = PostcodeParser(pc_config)
  98
  99     result = parser.parse(mk_query(query))
 100
 101     assert result == {(frm, to, '345987')}
 102
 103
 104 def test_overlapping_postcode(pc_config):
 105     parser = PostcodeParser(pc_config)
 106
 107     assert parser.parse(mk_query('123 456 78')) == {(0, 2, '123456'), (1, 3, '456 78')}
 108
 109
 110 @pytest.mark.parametrize('query', ['45325-Berlin', "45325'Berlin",
 111                                    'Berlin-45325', "Berlin'45325", '45325Berlin'
 112                                    '345-987', "345'987", '345,987', '345:987'])
 113 def test_not_a_postcode(pc_config, query):
 114     parser = PostcodeParser(pc_config)
 115
 116     assert not parser.parse(mk_query(query))
 117
 118
 119 @pytest.mark.parametrize('query', ['ba 12233', 'ba-12233'])
 120 def test_postcode_with_country_prefix(pc_config, query):
 121     parser = PostcodeParser(pc_config)
 122
 123     assert (0, 2, '12233') in parser.parse(mk_query(query))
 124
 125
 126 def test_postcode_with_joined_country_prefix(pc_config):
 127     parser = PostcodeParser(pc_config)
 128
 129     assert parser.parse(mk_query('ba12233')) == {(0, 1, '12233')}
 130
 131
 132 def test_postcode_with_non_matching_country_prefix(pc_config):
 133     parser = PostcodeParser(pc_config)
 134
 135     assert not parser.parse(mk_query('ky12233'))
 136
 137
 138 def test_postcode_inside_postcode_phrase(pc_config):
 139     parser = PostcodeParser(pc_config)
 140
 141     query = QueryStruct([])
 142     query.nodes[-1].ptype = PHRASE_STREET
 143     query.add_node(',', PHRASE_STREET, 0.1, '12345', '12345')
 144     query.add_node(',', PHRASE_POSTCODE, 0.1, 'xz', 'xz')
 145     query.add_node('>', PHRASE_POSTCODE, 0.1, '4444', '4444')
 146
 147     assert parser.parse(query) == {(2, 3, '4444')}
 148
 149
 150 def test_partial_postcode_in_postcode_phrase(pc_config):
 151     parser = PostcodeParser(pc_config)
 152
 153     query = QueryStruct([])
 154     query.nodes[-1].ptype = PHRASE_POSTCODE
 155     query.add_node(' ', PHRASE_POSTCODE, 0.1, '2224', '2224')
 156     query.add_node('>', PHRASE_POSTCODE, 0.1, '12345', '12345')
 157
 158     assert not parser.parse(query)