remove old bdd tests

diff --git a/tests/features/api/details.feature b/tests/features/api/details.feature
deleted file mode 100644 (file)
index e59659c..0000000
--- a/tests/features/api/details.feature
+++ /dev/null
@@ -1,13 +0,0 @@
-Feature: Object details
-    Check details page for correctness
-
-    Scenario Outline: Details via OSM id
-        When looking up details for <object>
-        Then the result is valid
-
-    Examples:
-     | object
-     | 1758375
-     | N158845944
-     | W72493656
-     | R62422

diff --git a/tests/features/api/language.feature b/tests/features/api/language.feature
deleted file mode 100644 (file)
index 529dc02..0000000
--- a/tests/features/api/language.feature
+++ /dev/null
@@ -1,100 +0,0 @@
-Feature: Localization of search results
-
-    Scenario: Search - default language
-        When sending json search query "Germany"
-        Then results contain
-          | ID | display_name
-          | 0  | Deutschland.*
-
-    Scenario: Search - accept-language first
-        Given the request parameters
-          | accept-language
-          | en,de
-        When sending json search query "Deutschland"
-        Then results contain
-          | ID | display_name
-          | 0  | Germany.*
-        
-    Scenario: Search - accept-language missing
-        Given the request parameters
-          | accept-language
-          | xx,fr,en,de
-        When sending json search query "Deutschland"
-        Then results contain
-          | ID | display_name
-          | 0  | Allemagne.*
-
-    Scenario: Search - http accept language header first
-        Given the HTTP header
-          | accept-language
-          | fr-ca,fr;q=0.8,en-ca;q=0.5,en;q=0.3
-        When sending json search query "Deutschland"
-        Then results contain
-          | ID | display_name
-          | 0  | Allemagne.*
-
-    Scenario: Search - http accept language header and accept-language
-        Given the request parameters
-          | accept-language
-          | de,en
-        Given the HTTP header
-          | accept-language
-          | fr-ca,fr;q=0.8,en-ca;q=0.5,en;q=0.3
-        When sending json search query "Deutschland"
-        Then results contain
-          | ID | display_name
-          | 0  | Deutschland.*
-
-    Scenario: Search - http accept language header fallback
-        Given the HTTP header
-          | accept-language
-          | fr-ca,en-ca;q=0.5
-        When sending json search query "Deutschland"
-        Then results contain
-          | ID | display_name
-          | 0  | Allemagne.*
-
-    Scenario: Search - http accept language header fallback (upper case)
-        Given the HTTP header
-          | accept-language
-          | fr-FR;q=0.8,en-ca;q=0.5
-        When sending json search query "Deutschland"
-        Then results contain
-          | ID | display_name
-          | 0  | Allemagne.*
-
-    Scenario: Reverse - default language
-        When looking up coordinates 48.13921,11.57328
-        Then result addresses contain
-          | ID | city
-          | 0  | München
-
-    Scenario: Reverse - accept-language parameter
-        Given the request parameters
-          | accept-language
-          | en,fr
-        When looking up coordinates 48.13921,11.57328
-        Then result addresses contain
-          | ID | city
-          | 0  | Munich
-
-    Scenario: Reverse - HTTP accept language header
-        Given the HTTP header
-          | accept-language
-          | fr-ca,fr;q=0.8,en-ca;q=0.5,en;q=0.3
-        When looking up coordinates 48.13921,11.57328
-        Then result addresses contain
-          | ID | city
-          | 0  | Munich
-    
-    Scenario: Reverse - accept-language parameter and HTTP header
-        Given the request parameters
-          | accept-language
-          | it
-        Given the HTTP header
-          | accept-language
-          | fr-ca,fr;q=0.8,en-ca;q=0.5,en;q=0.3
-        When looking up coordinates 48.13921,11.57328
-        Then result addresses contain
-          | ID | city
-          | 0  | Monaco di Baviera

diff --git a/tests/features/api/lookup.feature b/tests/features/api/lookup.feature
deleted file mode 100644 (file)
index 7b86fb4..0000000
--- a/tests/features/api/lookup.feature
+++ /dev/null
@@ -1,15 +0,0 @@
-Feature: Places by osm_type and osm_id Tests
-    Simple tests for internal server errors and response format.
-
-    Scenario: address lookup for existing node, way, relation
-        When looking up xml places N158845944,W72493656,,R62422,X99,N0
-        Then the result is valid xml
-        exactly 3 results are returned
-        When looking up json places N158845944,W72493656,,R62422,X99,N0
-        Then the result is valid json
-        exactly 3 results are returned
-
-    Scenario: address lookup for non-existing or invalid node, way, relation
-        When looking up xml places X99,,N0,nN158845944,ABC,,W9
-        Then the result is valid xml
-        exactly 0 results are returned
\ No newline at end of file

diff --git a/tests/features/api/regression.feature b/tests/features/api/regression.feature
deleted file mode 100644 (file)
index 08156d6..0000000
--- a/tests/features/api/regression.feature
+++ /dev/null
@@ -1,217 +0,0 @@
-Feature: API regression tests
-    Tests error cases reported in tickets.
-
-    Scenario: trac #2430
-        When sending json search query "89 River Avenue, Hoddesdon, Hertfordshire, EN11 0JT"
-        Then at least 1 result is returned
-
-    Scenario: trac #2440
-        When sending json search query "East Harvard Avenue, Denver"
-        Then more than 2 results are returned
-
-    Scenario: trac #2456
-        When sending xml search query "Borlänge Kommun"
-        Then results contain
-         | ID | place_rank
-         | 0  | 19
-
-    Scenario: trac #2530
-        When sending json search query "Lange Straße, Bamberg" with address
-        Then result addresses contain
-         | ID | town
-         | 0  | Bamberg
-
-    Scenario: trac #2541
-        When sending json search query "pad, germany"
-        Then results contain
-         | ID | class   | display_name
-         | 0  | aeroway | Paderborn/Lippstadt,.*
-
-    Scenario: trac #2579
-        When sending json search query "Johnsons Close, hackbridge" with address
-        Then result addresses contain
-         | ID | postcode
-         | 0  | SM5 2LU
-
-    @Fail
-    Scenario Outline: trac #2586
-        When sending json search query "<query>" with address
-        Then result addresses contain
-         | ID | country_code
-         | 0  | uk
-
-    Examples:
-        | query
-        | DL7 0SN
-        | DL70SN
-
-    Scenario: trac #2628 (1)
-        When sending json search query "Adam Kraft Str" with address
-        Then result addresses contain
-         | ID | road          
-         | 0  | Adam-Kraft-Straße
-
-    Scenario: trac #2628 (2)
-        When sending json search query "Maxfeldstr. 5, Nürnberg" with address
-        Then result addresses contain
-         | ID | house_number | road          | city
-         | 0  | 5            | Maxfeldstraße | Nürnberg
-
-    Scenario: trac #2638
-        When sending json search query "Nöthnitzer Str. 40, 01187 Dresden" with address
-        Then result addresses contain
-         | ID | house_number | road              | city
-         | 0  | 40           | Nöthnitzer Straße | Dresden
-
-    Scenario Outline: trac #2667
-        When sending json search query "<query>" with address
-        Then result addresses contain
-         | ID | house_number
-         | 0  | <number>
-
-    Examples:
-        | number | query
-        | 16     | 16 Woodpecker Way, Cambourne
-        | 14906  | 14906, 114 Street Northwest, Edmonton, Alberta, Canada
-        | 14904  | 14904, 114 Street Northwest, Edmonton, Alberta, Canada
-        | 15022  | 15022, 114 Street Northwest, Edmonton, Alberta, Canada
-        | 15024  | 15024, 114 Street Northwest, Edmonton, Alberta, Canada
-
-    Scenario: trac #2681
-        When sending json search query "kirchstraße troisdorf Germany"
-        Then results contain
-         | ID | display_name
-         | 0  | .*, Troisdorf, .*
-
-    Scenario: trac #2758
-        When sending json search query "6а, полуботка, чернигов" with address
-        Then result addresses contain
-         | ID | house_number
-         | 0  | 6а
-
-    Scenario: trac #2790
-        When looking up coordinates 49.0942079697809,8.27565898861822
-        Then result addresses contain
-         | ID | road          | village  | country
-         | 0  | Daimlerstraße | Jockgrim | Deutschland
-
-    Scenario: trac #2794
-        When sending json search query "4008"
-        Then results contain
-         | ID | class | type
-         | 0  | place | postcode
-
-    Scenario: trac #2797
-        When sending json search query "Philippstr.4, 52349 Düren" with address
-        Then result addresses contain
-         | ID | road          | town
-         | 0  | Philippstraße | Düren
-
-    Scenario: trac #2830
-        When sending json search query "207, Boardman Street, S0J 1L0, CA" with address
-        Then result addresses contain
-         | ID | house_number | road            | postcode | country
-         | 0  | 207          | Boardman Street | S0J 1L0  | Canada
-
-    Scenario: trac #2830
-        When sending json search query "S0J 1L0,CA"
-        Then results contain
-         | ID | class | type     | display_name
-         | 0  | place | postcode | .*, Canada
-
-    Scenario: trac #2845
-        When sending json search query "Leliestraat 31, Zwolle" with address
-        Then result addresses contain
-         | ID | city
-         | 0  | Zwolle
-
-    Scenario: trac #2852
-        When sending json search query "berlinerstrasse, leipzig" with address
-        Then result addresses contain
-         | ID | road
-         | 0  | Berliner Straße
-
-    Scenario: trac #2871
-        When looking up coordinates -33.906895553,150.99609375
-        Then result addresses contain
-         | ID | city       | country
-         | 0  | [^0-9]*$   | Australia
-
-     Scenario: trac #2981
-        When sending json search query "Ohmstraße 7, Berlin" with address
-        Then at least 2 results are returned
-        And result addresses contain
-         | house_number | road      | state
-         | 7            | Ohmstraße | Berlin
-
-     Scenario: trac #3049
-        When sending json search query "Soccer City"
-        Then results contain
-         | ID | class   | type    | latlon
-         | 0  | leisure | stadium | -26.2347261,27.982645 +-50m
-
-     Scenario: trac #3130
-        When sending json search query "Old Way, Frinton"
-        Then results contain
-         | ID | class   | latlon
-         | 0  | highway | 51.8324206,1.2447352 +-100m
-
-     Scenario Outline: trac #5025
-        When sending json search query "Kriegsstr <house_nr>, Karlsruhe" with address
-        Then result addresses contain
-          | house_number | road
-          | <house_nr>   | Kriegsstraße
-
-     Examples:
-        | house_nr
-        | 5c
-        | 25
-        | 78
-        | 80
-        | 99
-        | 130
-        | 153
-        | 196
-        | 256
-        | 294
-
-     Scenario: trac #5238
-        Given the request parameters
-         | bounded | viewbox
-         | 1       | -1,0,0,-1
-        When sending json search query "sy"
-        Then exactly 0 results are returned
-
-    Scenario: trac #5274
-        When sending json search query "Goedestraat 41-BS, Utrecht" with address
-        Then result addresses contain
-          | house_number | road        | city
-          | 41-BS        | Goedestraat | Utrecht
-
-    @poldi-only
-    Scenario Outline: github #36
-        When sending json search query "<query>" with address
-        Then result addresses contain
-         | ID | road     | city
-         | 0  | Seegasse | .*Wieselburg-Land
-
-    Examples:
-         | query
-         | Seegasse, Gemeinde Wieselburg-Land
-         | Seegasse, Wieselburg-Land
-         | Seegasse, Wieselburg
-
-    Scenario: github #190
-        When looking up place N257363453
-        Then the results contain
-         | osm_type   | osm_id     | latlon
-         | node       | 257363453  | 35.8404121,128.5586643 +-100m
-
-    Scenario: trac #5427
-        Given the request parameters
-         | countrycodes |
-         | DE           |
-        When sending json search query "12345" with address
-        Then result addresses contain
-         | country_code |
-         | de           |

diff --git a/tests/features/api/reverse.feature b/tests/features/api/reverse.feature
deleted file mode 100644 (file)
index 7bd1291..0000000
--- a/tests/features/api/reverse.feature
+++ /dev/null
@@ -1,148 +0,0 @@
-Feature: Reverse geocoding
-    Testing the reverse function
-
-    # Make sure country is not overwritten by the postcode
-    Scenario: Country is returned
-        Given the request parameters
-          | accept-language
-          | de
-        When looking up coordinates 53.9788769,13.0830313
-        Then result addresses contain 
-         | ID | country
-         | 0  | Deutschland
-
-
-    Scenario: Boundingbox is returned
-        Given the request parameters
-          | format | zoom
-          | xml    | 4
-        When looking up coordinates 53.9788769,13.0830313
-        And results contain valid boundingboxes
-
-    Scenario: Reverse geocoding for odd interpolated housenumber
-
-    Scenario: Reverse geocoding for even interpolated housenumber
-
-    @Tiger
-    Scenario: TIGER house number
-        Given the request parameters
-          | addressdetails
-          | 1
-        When looking up jsonv2 coordinates 40.6863624710666,-112.060005720023
-        And exactly 1 result is returned
-        And result addresses contain
-          | ID | house_number | road               | postcode | country_code
-          | 0  | 709.         | Kings Estate Drive | 84128    | us
-        And results contain
-          | osm_type | category | type
-          | way      | place    | house
-
-    @Tiger
-    Scenario: No TIGER house number for zoom < 18
-        Given the request parameters
-          | addressdetails | zoom
-          | 1              | 17
-        When looking up coordinates 40.6863624710666,-112.060005720023
-        And exactly 1 result is returned
-        And result addresses contain
-          | ID | road               | postcode | country_code
-          | 0  | Kings Estate Drive | 84128    | us
-        And result 0 has attributes osm_id,osm_type
-
-   Scenario Outline: Reverse Geocoding with extratags
-        Given the request parameters
-          | extratags
-          | 1
-        When looking up <format> coordinates 48.86093,2.2978
-        Then result 0 has attributes extratags
-
-   Examples:
-        | format
-        | xml
-        | json
-        | jsonv2
-
-   Scenario Outline: Reverse Geocoding with namedetails
-        Given the request parameters
-          | namedetails
-          | 1
-        When looking up <format> coordinates 48.86093,2.2978
-        Then result 0 has attributes namedetails
-
-   Examples:
-        | format
-        | xml
-        | json
-        | jsonv2
-
-
-   Scenario Outline: Reverse Geocoding contains TEXT geometry
-        Given the request parameters
-          | polygon_text
-          | 1
-        When looking up <format> coordinates 48.86093,2.2978
-        Then result 0 has attributes <response_attribute>
-
-   Examples:
-        | format   | response_attribute
-        | xml      | geotext
-        | json     | geotext
-        | jsonv2   | geotext
-
-   Scenario Outline: Reverse Geocoding contains polygon-as-points geometry
-        Given the request parameters
-          | polygon
-          | 1
-        When looking up <format> coordinates 48.86093,2.2978
-        Then result 0 has not attributes <response_attribute>
-
-   Examples:
-        | format   | response_attribute
-        | xml      | polygonpoints
-        | json     | polygonpoints
-        | jsonv2   | polygonpoints
-
-
-
-   Scenario Outline: Reverse Geocoding contains SVG geometry
-        Given the request parameters
-          | polygon_svg
-          | 1
-        When looking up <format> coordinates 48.86093,2.2978
-        Then result 0 has attributes <response_attribute>
-
-   Examples:
-        | format   | response_attribute
-        | xml      | geosvg
-        | json     | svg
-        | jsonv2   | svg
-
-
-   Scenario Outline: Reverse Geocoding contains KML geometry
-        Given the request parameters
-          | polygon_kml
-          | 1
-        When looking up <format> coordinates 48.86093,2.2978
-        Then result 0 has attributes <response_attribute>
-
-   Examples:
-        | format   | response_attribute
-        | xml      | geokml
-        | json     | geokml
-        | jsonv2   | geokml
-
-
-   Scenario Outline: Reverse Geocoding contains GEOJSON geometry
-        Given the request parameters
-          | polygon_geojson
-          | 1
-        When looking up <format> coordinates 48.86093,2.2978
-        Then result 0 has attributes <response_attribute>
-
-   Examples:
-        | format   | response_attribute
-        | xml      | geojson
-        | json     | geojson
-        | jsonv2   | geojson
-
-

diff --git a/tests/features/api/reverse_by_id.feature b/tests/features/api/reverse_by_id.feature
deleted file mode 100644 (file)
index 5f5a8f8..0000000
--- a/tests/features/api/reverse_by_id.feature
+++ /dev/null
@@ -1,13 +0,0 @@
-Feature: Reverse lookup by ID
-    Testing reverse geocoding via OSM ID
-
-    # see github issue #269
-    Scenario: Get address of linked places
-        Given the request parameters
-          | osm_type | osm_id
-          | N        | 151421301
-        When sending an API call reverse
-        Then exactly 1 result is returned
-        And result addresses contain
-          | county       | state
-          | Pratt County | Kansas

diff --git a/tests/features/api/reverse_simple.feature b/tests/features/api/reverse_simple.feature
deleted file mode 100644 (file)
index 6100f54..0000000
--- a/tests/features/api/reverse_simple.feature
+++ /dev/null
@@ -1,140 +0,0 @@
-Feature: Simple Reverse Tests
-    Simple tests for internal server errors and response format.
-    These tests should pass on any Nominatim installation.
-
-    Scenario Outline: Simple reverse-geocoding
-        When looking up xml coordinates <lat>,<lon>
-        Then the result is valid xml
-        When looking up json coordinates <lat>,<lon>
-        Then the result is valid json
-        When looking up jsonv2 coordinates <lat>,<lon>
-        Then the result is valid json
-
-    Examples:
-     | lat      | lon
-     | 0.0      | 0.0
-     | 45.3     | 3.5
-     | -79.34   | 23.5
-     | 0.23     | -178.555
-
-    Scenario Outline: Testing different parameters
-        Given the request parameters
-          | <parameter>
-          | <value>
-        When sending search query "Manchester"
-        Then the result is valid html
-        Given the request parameters
-          | <parameter>
-          | <value>
-        When sending html search query "Manchester"
-        Then the result is valid html
-        Given the request parameters
-          | <parameter>
-          | <value>
-        When sending xml search query "Manchester"
-        Then the result is valid xml
-        Given the request parameters
-          | <parameter>
-          | <value>
-        When sending json search query "Manchester"
-        Then the result is valid json
-        Given the request parameters
-          | <parameter>
-          | <value>
-        When sending jsonv2 search query "Manchester"
-        Then the result is valid json
-
-    Examples:
-     | parameter        | value
-     | polygon          | 1
-     | polygon          | 0
-     | polygon_text     | 1
-     | polygon_text     | 0
-     | polygon_kml      | 1
-     | polygon_kml      | 0
-     | polygon_geojson  | 1
-     | polygon_geojson  | 0
-     | polygon_svg      | 1
-     | polygon_svg      | 0
-
-
-
-
-    Scenario Outline: Wrapping of legal jsonp requests
-        Given the request parameters
-        | json_callback
-        | foo
-        When looking up <format> coordinates 67.3245,0.456
-        Then the result is valid json
-
-    Examples:
-      | format
-      | json
-      | jsonv2
-
-    Scenario: Reverse-geocoding without address
-        Given the request parameters
-          | addressdetails
-          | 0
-        When looking up xml coordinates 36.791966,127.171726
-        Then the result is valid xml
-        When looking up json coordinates 36.791966,127.171726
-        Then the result is valid json
-        When looking up jsonv2 coordinates 36.791966,127.171726
-        Then the result is valid json
-
-    Scenario: Reverse-geocoding with zoom
-        Given the request parameters
-          | zoom
-          | 10
-        When looking up xml coordinates 36.791966,127.171726
-        Then the result is valid xml
-        When looking up json coordinates 36.791966,127.171726
-        Then the result is valid json
-        When looking up jsonv2 coordinates 36.791966,127.171726
-        Then the result is valid json
-
-    Scenario: Missing lon parameter
-        Given the request parameters
-          | lat
-          | 51.51
-        When sending an API call reverse
-        Then a HTTP 400 is returned
-
-    Scenario: Missing lat parameter
-        Given the request parameters
-          | lon
-          | -79.39114
-        When sending an API call reverse
-        Then a HTTP 400 is returned
-
-    Scenario: Missing osm_id parameter
-        Given the request parameters
-          | osm_type
-          | N
-        When sending an API call reverse
-        Then a HTTP 400 is returned
-
-    Scenario: Missing osm_type parameter
-        Given the request parameters
-          | osm_id
-          | 3498564
-        When sending an API call reverse
-        Then a HTTP 400 is returned
-
-    Scenario Outline: Bad format for lat or lon
-        Given the request parameters
-          | lat   | lon   |
-          | <lat> | <lon> |
-        When sending an API call reverse
-        Then a HTTP 400 is returned
-
-    Examples:
-     | lat      | lon
-     | 48.9660  | 8,4482
-     | 48,9660  | 8.4482
-     | 48,9660  | 8,4482
-     | 48.966.0 | 8.4482
-     | 48.966   | 8.448.2
-     | Nan      | 8.448
-     | 48.966   | Nan

diff --git a/tests/features/api/search.feature b/tests/features/api/search.feature
deleted file mode 100644 (file)
index 91050da..0000000
--- a/tests/features/api/search.feature
+++ /dev/null
@@ -1,86 +0,0 @@
-Feature: Search queries
-    Testing correctness of results
-
-    Scenario: UK House number search
-        When sending json search query "27 Thoresby Road, Broxtowe" with address
-        Then address of result 0 contains
-          | type         | value
-          | house_number | 27
-          | road         | Thoresby Road
-          | city         | Broxtowe
-          | state        | England
-          | country      | U.*K.*
-          | country_code | gb
-
-
-    Scenario: House number search for non-street address
-        Given the request parameters
-          | accept-language
-          | en
-        When sending json search query "4 Pomocnia, Pokrzywnica, Poland" with address
-        Then address of result 0 contains
-          | type         | value
-          | house_number | 4
-          | county       | gmina Pokrzywnica
-          | state        | Masovian Voivodeship
-          | postcode     | 06-121
-          | country      | Poland
-          | country_code | pl
-        Then address of result 0 does not contain road
-
-    Scenario: House number interpolation even
-        Given the request parameters
-          | accept-language
-          | en
-        When sending json search query "140 rue Don Bosco, Saguenay" with address
-        Then address of result 0 contains
-          | type         | value
-          | house_number | 140
-          | road         | [Rr]ue Don Bosco
-          | city         | .*Saguenay
-          | state        | Quebec
-          | country      | Canada
-          | country_code | ca
-
-    Scenario: House number interpolation odd
-        Given the request parameters
-          | accept-language
-          | en
-        When sending json search query "141 rue Don Bosco, Saguenay" with address
-        Then address of result 0 contains
-          | type         | value
-          | house_number | 141
-          | road         | [rR]ue Don Bosco
-          | city         | .*Saguenay
-          | state        | Quebec
-          | country      | Canada
-          | country_code | ca
-
-    @Tiger
-    Scenario: TIGER house number
-        When sending json search query "3 West Victory Way, Craig"
-        Then results contain
-         | osm_type
-         | way
-
-    @Tiger
-    Scenario: TIGER house number (road fallback)
-        When sending json search query "3030 West Victory Way, Craig"
-        Then results contain
-         | osm_type
-         | way
-
-    Scenario: Expansion of Illinois
-        Given the request parameters
-          | accept-language
-          | en
-        When sending json search query "il, us"
-        Then results contain
-          | ID | display_name
-          | 0  | Illinois.*
-
-    Scenario: Search with class-type feature
-        When sending jsonv2 search query "Hotel California"
-        Then results contain
-          | place_rank
-          | 30

diff --git a/tests/features/api/search_order.feature b/tests/features/api/search_order.feature
deleted file mode 100644 (file)
index fad5e89..0000000
--- a/tests/features/api/search_order.feature
+++ /dev/null
@@ -1,36 +0,0 @@
-Feature: Result order for Geocoding
-    Testing that importance ordering returns sensible results
-
-    Scenario Outline: city order in street search
-        Given the request parameters
-          | limit
-          | 100
-        When sending json search query "<street>, <city>" with address
-        Then address of result 0 contains
-         | type   | value
-         | <type> | <city>
-
-    Examples:
-        | type   | city            | street
-        | city   | Zürich          | Rigistr
-        | city   | Karlsruhe       | Sophienstr
-        | city   | München         | Karlstr
-        | city   | Praha           | Dlouhá
-
-    Scenario Outline: use more important city in street search
-        When sending json search query "<street>, <city>" with address
-        Then result addresses contain
-          | ID | country_code
-          | 0  | <country>
-
-    Examples:
-        | country | city       | street
-        | gb      | London     | Main St
-        | gb      | Manchester | Central Street
-
-    # https://trac.openstreetmap.org/ticket/5094
-    Scenario: housenumbers are ordered by complete match first
-        When sending json search query "4 Докукина Москва" with address
-        Then result addresses contain
-          | ID | house_number
-          | 0  | 4

diff --git a/tests/features/api/search_params.feature b/tests/features/api/search_params.feature
deleted file mode 100644 (file)
index cd0db09..0000000
--- a/tests/features/api/search_params.feature
+++ /dev/null
@@ -1,315 +0,0 @@
-Feature: Search queries
-    Testing different queries and parameters
-
-    Scenario: Simple XML search
-        When sending xml search query "Schaan"
-        Then result 0 has attributes place_id,osm_type,osm_id
-        And result 0 has attributes place_rank,boundingbox
-        And result 0 has attributes lat,lon,display_name
-        And result 0 has attributes class,type,importance,icon
-        And result 0 has not attributes address
-        And results contain valid boundingboxes
-
-    Scenario: Simple JSON search
-        When sending json search query "Vaduz"
-        And result 0 has attributes place_id,licence,icon,class,type
-        And result 0 has attributes osm_type,osm_id,boundingbox
-        And result 0 has attributes lat,lon,display_name,importance
-        And result 0 has not attributes address
-        And results contain valid boundingboxes
-
-    Scenario: JSON search with addressdetails
-        When sending json search query "Montevideo" with address
-        Then address of result 0 is
-          | type         | value
-          | city         | Montevideo
-          | state        | Montevideo
-          | country      | Uruguay
-          | country_code | uy
-
-    Scenario: XML search with addressdetails
-        When sending xml search query "Inuvik" with address
-        Then address of result 0 contains
-          | type         | value
-          | state        | Northwest Territories
-          | country      | Canada
-          | country_code | ca
-
-    Scenario: coordinate search with addressdetails
-        When sending json search query "51.193058013916,15.5245780944824" with address
-        Then result addresses contain
-          | village    | country | country_code
-          | Kraszowice | Polska  | pl
-
-    Scenario: Address details with unknown class types
-        When sending json search query "foobar, Essen" with address
-        Then results contain
-          | ID | class   | type
-          | 0  | leisure | hackerspace
-        And result addresses contain
-          | ID | address29
-          | 0  | Chaospott
-        And address of result 0 does not contain leisure,hackerspace
-
-    Scenario: Disabling deduplication
-        When sending json search query "Oxford Street, London"
-        Then there are no duplicates
-        Given the request parameters
-          | dedupe
-          | 0
-        When sending json search query "Oxford Street, London"
-        Then there are duplicates
-
-    Scenario: Search with bounded viewbox in right area
-        Given the request parameters
-          | bounded | viewbox
-          | 1       | -87.7,41.9,-87.57,41.85
-        When sending json search query "restaurant" with address
-        Then result addresses contain
-          | ID | city
-          | 0  | Chicago
-
-    Scenario: Search with bounded viewboxlbrt in right area
-        Given the request parameters
-          | bounded | viewboxlbrt
-          | 1       | -87.7,41.85,-87.57,41.9
-        When sending json search query "restaurant" with address
-        Then result addresses contain
-          | ID | city
-          | 0  | Chicago
-
-    Scenario: No POI search with unbounded viewbox
-        Given the request parameters
-          | viewbox
-          | -87.7,41.9,-87.57,41.85
-        When sending json search query "restaurant"
-        Then results contain
-          | display_name
-          | [^,]*(?i)restaurant.*
-
-    Scenario: bounded search remains within viewbox, even with no results
-        Given the request parameters
-         | bounded | viewbox
-         | 1       | 43.5403125,-5.6563282,43.54285,-5.662003
-         When sending json search query "restaurant"
-        Then less than 1 result is returned
-
-    Scenario: bounded search remains within viewbox with results
-        Given the request parameters
-         | bounded | viewbox
-         | 1       | -5.662003,43.55,-5.6563282,43.5403125
-        When sending json search query "restaurant"
-         | lon          | lat
-         | >= -5.662003 | >= 43.5403125
-         | <= -5.6563282| <= 43.55
-
-    Scenario: Prefer results within viewbox
-        Given the request parameters
-          | accept-language
-          | en
-        When sending json search query "royan" with address
-        Then result addresses contain
-          | ID | country
-          | 0  | France
-        Given the request parameters
-          | accept-language | viewbox
-          | en              | 51.94,36.59,51.99,36.56
-        When sending json search query "royan" with address
-        Then result addresses contain
-          | ID | country
-          | 0  | Iran
-
-    Scenario: Overly large limit number for search results
-        Given the request parameters
-          | limit
-          | 1000
-        When sending json search query "Neustadt"
-        Then at most 50 results are returned
-
-    Scenario: Limit number of search results
-        Given the request parameters
-          | limit
-          | 4
-        When sending json search query "Neustadt"
-        Then exactly 4 results are returned
-
-    Scenario: Restrict to feature type country
-        Given the request parameters
-          | featureType
-          | country
-        When sending xml search query "Monaco"
-        Then results contain
-          | place_rank
-          | 4
-
-    Scenario: Restrict to feature type state
-        When sending xml search query "Berlin"
-        Then results contain
-          | ID | place_rank
-          | 0  | 1[56]
-        Given the request parameters
-          | featureType
-          | state
-        When sending xml search query "Berlin"
-        Then results contain
-          | place_rank
-          | [78]
-
-    Scenario: Restrict to feature type city
-        Given the request parameters
-          | featureType
-          | city
-        When sending xml search query "Monaco"
-        Then results contain
-          | place_rank
-          | 1[56789]
-
-
-    Scenario: Restrict to feature type settlement
-        When sending json search query "Everest"
-        Then results contain
-          | ID | display_name
-          | 0  | Mount Everest.*
-        Given the request parameters
-          | featureType
-          | settlement
-        When sending json search query "Everest"
-        Then results contain
-          | ID | display_name
-          | 0  | Everest.*
-
-    Scenario Outline: Search with polygon threshold (json)
-        Given the request parameters
-          | polygon_geojson | polygon_threshold
-          | 1               | <th>
-        When sending json search query "switzerland"
-        Then at least 1 result is returned
-        And result 0 has attributes geojson
-
-     Examples:
-        | th
-        | -1
-        | 0.0
-        | 0.5
-        | 999
-
-    Scenario Outline: Search with polygon threshold (xml)
-        Given the request parameters
-          | polygon_geojson | polygon_threshold
-          | 1               | <th>
-        When sending xml search query "switzerland"
-        Then at least 1 result is returned
-        And result 0 has attributes geojson
-
-     Examples:
-        | th
-        | -1
-        | 0.0
-        | 0.5
-        | 999
-
-    Scenario Outline: Search with invalid polygon threshold (xml)
-        Given the request parameters
-          | polygon_geojson | polygon_threshold
-          | 1               | <th>
-        When sending xml search query "switzerland"
-        Then a HTTP 400 is returned
-
-
-    Scenario Outline: Search with extratags
-        Given the request parameters
-          | extratags
-          | 1
-        When sending <format> search query "Hauptstr"
-        Then result 0 has attributes extratags
-        And result 1 has attributes extratags
-
-    Examples:
-        | format
-        | xml
-        | json
-        | jsonv2
-
-    Scenario Outline: Search with namedetails
-        Given the request parameters
-          | namedetails
-          | 1
-        When sending <format> search query "Hauptstr"
-        Then result 0 has attributes namedetails
-        And result 1 has attributes namedetails
-
-    Examples:
-        | format
-        | xml
-        | json
-        | jsonv2
-
-
-   Scenario Outline: Search result with contains TEXT geometry
-        Given the request parameters
-          | polygon_text
-          | 1
-        When sending <format> search query "switzerland"
-        Then result 0 has attributes <response_attribute>
-
-   Examples:
-        | format   | response_attribute
-        | xml      | geotext
-        | json     | geotext
-        | jsonv2   | geotext
-
-   Scenario Outline: Search result contains polygon-as-points geometry
-        Given the request parameters
-          | polygon
-          | 1
-        When sending <format> search query "switzerland"
-        Then result 0 has attributes <response_attribute>
-
-   Examples:
-        | format   | response_attribute
-        | xml      | polygonpoints
-        | json     | polygonpoints
-        | jsonv2   | polygonpoints
-
-
-
-   Scenario Outline: Search result contains SVG geometry
-        Given the request parameters
-          | polygon_svg
-          | 1
-        When sending <format> search query "switzerland"
-        Then result 0 has attributes <response_attribute>
-
-   Examples:
-        | format   | response_attribute
-        | xml      | geosvg
-        | json     | svg
-        | jsonv2   | svg
-
-
-   Scenario Outline: Search result contains KML geometry
-        Given the request parameters
-          | polygon_kml
-          | 1
-        When sending <format> search query "switzerland"
-        Then result 0 has attributes <response_attribute>
-
-   Examples:
-        | format   | response_attribute
-        | xml      | geokml
-        | json     | geokml
-        | jsonv2   | geokml
-
-
-   Scenario Outline: Search result contains GEOJSON geometry
-        Given the request parameters
-          | polygon_geojson
-          | 1
-        When sending <format> search query "switzerland"
-        Then result 0 has attributes <response_attribute>
-
-   Examples:
-        | format   | response_attribute
-        | xml      | geojson
-        | json     | geojson
-        | jsonv2   | geojson

diff --git a/tests/features/api/search_simple.feature b/tests/features/api/search_simple.feature
deleted file mode 100644 (file)
index 0020cc2..0000000
--- a/tests/features/api/search_simple.feature
+++ /dev/null
@@ -1,238 +0,0 @@
-Feature: Simple Tests
-    Simple tests for internal server errors and response format.
-    These tests should pass on any Nominatim installation.
-
-    Scenario Outline: Testing different parameters
-        Given the request parameters
-          | <parameter>
-          | <value>
-        When sending search query "Manchester"
-        Then the result is valid html
-        Given the request parameters
-          | <parameter>
-          | <value>
-        When sending html search query "Manchester"
-        Then the result is valid html
-        Given the request parameters
-          | <parameter>
-          | <value>
-        When sending xml search query "Manchester"
-        Then the result is valid xml
-        Given the request parameters
-          | <parameter>
-          | <value>
-        When sending json search query "Manchester"
-        Then the result is valid json
-        Given the request parameters
-          | <parameter>
-          | <value>
-        When sending jsonv2 search query "Manchester"
-        Then the result is valid json
-
-    Examples:
-     | parameter        | value
-     | addressdetails   | 1
-     | addressdetails   | 0
-     | polygon          | 1
-     | polygon          | 0
-     | polygon_text     | 1
-     | polygon_text     | 0
-     | polygon_kml      | 1
-     | polygon_kml      | 0
-     | polygon_geojson  | 1
-     | polygon_geojson  | 0
-     | polygon_svg      | 1
-     | polygon_svg      | 0
-     | accept-language  | de,en
-     | countrycodes     | uk,ir
-     | bounded          | 1
-     | bounded          | 0
-     | exclude_place_ids| 385252,1234515
-     | limit            | 1000
-     | dedupe           | 1
-     | dedupe           | 0
-     | extratags        | 1
-     | extratags        | 0
-     | namedetails      | 1
-     | namedetails      | 0
-
-    Scenario: Search with invalid output format
-        Given the request parameters
-          | format
-          | fd$#
-        When sending search query "Berlin"
-        Then a HTTP 400 is returned
-
-    Scenario Outline: Simple Searches
-        When sending search query "<query>"
-        Then the result is valid html
-        When sending html search query "<query>"
-        Then the result is valid html
-        When sending xml search query "<query>"
-        Then the result is valid xml
-        When sending json search query "<query>"
-        Then the result is valid json
-        When sending jsonv2 search query "<query>"
-        Then the result is valid json
-
-    Examples:
-     | query
-     | New York, New York
-     | France
-     | 12, Main Street, Houston
-     | München
-     | 東京都
-     | hotels in nantes
-     | xywxkrf
-     | gh; foo()
-     | %#$@*&l;der#$!
-     | 234
-     | 47.4,8.3
-
-    Scenario: Empty XML search
-        When sending xml search query "xnznxvcx"
-        Then result header contains
-          | attr        | value
-          | querystring | xnznxvcx
-          | polygon     | false
-          | more_url    | .*format=xml.*q=xnznxvcx.*
-
-    Scenario: Empty XML search with special XML characters
-        When sending xml search query "xfdghn&zxn"xvbyx<vxx>cssdex"
-        Then result header contains
-          | attr        | value
-          | querystring | xfdghn&zxn"xvbyx<vxx>cssdex
-          | polygon     | false
-          | more_url    | .*format=xml.*q=xfdghn&zxn"xvbyx<vxx>cssdex.*
-
-    Scenario: Empty XML search with viewbox
-        Given the request parameters
-          | viewbox
-          | 12,45.13,77,33
-        When sending xml search query "xnznxvcx"
-        Then result header contains
-          | attr        | value
-          | querystring | xnznxvcx
-          | polygon     | false
-          | viewbox     | 12,45.13,77,33
-
-    Scenario: Empty XML search with viewboxlbrt
-        Given the request parameters
-          | viewboxlbrt
-          | 12,34.13,77,45
-        When sending xml search query "xnznxvcx"
-        Then result header contains
-          | attr        | value
-          | querystring | xnznxvcx
-          | polygon     | false
-          | viewbox     | 12,45.13,77,33
-
-    Scenario: Empty XML search with viewboxlbrt and viewbox
-        Given the request parameters
-          | viewbox        | viewboxblrt
-          | 12,45.13,77,33 | 1,2,3,4
-        When sending xml search query "pub"
-        Then result header contains
-          | attr        | value
-          | querystring | pub
-          | polygon     | false
-          | viewbox     | 12,45.13,77,33
-
-
-    Scenario Outline: Empty XML search with polygon values
-        Given the request parameters
-          | polygon
-          | <polyval>
-        When sending xml search query "xnznxvcx"
-        Then result header contains
-          | attr        | value
-          | polygon     | <result>
-
-    Examples:
-     | result | polyval
-     | false  | 0
-     | true   | 1
-     | true   | True
-     | true   | true
-     | true   | false
-     | true   | FALSE
-     | true   | yes
-     | true   | no
-     | true   | '; delete from foobar; select '
-
-
-    Scenario: Empty XML search with exluded place ids
-        Given the request parameters
-          | exclude_place_ids
-          | 123,76,342565
-        When sending xml search query "jghrleoxsbwjer"
-        Then result header contains
-          | attr              | value
-          | exclude_place_ids | 123,76,342565
-
-    Scenario: Empty XML search with bad exluded place ids
-        Given the request parameters
-          | exclude_place_ids
-          | ,
-        When sending xml search query "jghrleoxsbwjer"
-        Then result header has no attribute exclude_place_ids
-
-    Scenario Outline: Wrapping of legal jsonp search requests
-        Given the request parameters
-          | json_callback
-          | <data>
-        When sending json search query "Tokyo"
-        Then there is a json wrapper "<data>"
-
-    Examples:
-     | data
-     | foo
-     | FOO
-     | __world
-     | $me
-     | m1[4]
-     | d_r[$d]
-
-    Scenario Outline: Wrapping of illegal jsonp search requests
-        Given the request parameters
-          | json_callback
-          | <data>
-        When sending json search query "Tokyo"
-        Then a HTTP 400 is returned
-
-    Examples:
-      | data
-      | 1asd
-      | bar(foo)
-      | XXX['bad']
-      | foo; evil
-
-    Scenario Outline: Ignore jsonp parameter for anything but json
-        Given the request parameters
-          | json_callback
-          | 234
-        When sending json search query "Malibu"
-        Then a HTTP 400 is returned
-        Given the request parameters
-          | json_callback
-          | 234
-        When sending xml search query "Malibu"
-        Then the result is valid xml
-        Given the request parameters
-          | json_callback
-          | 234
-        When sending html search query "Malibu"
-        Then the result is valid html
-
-     Scenario: Empty JSON search
-        When sending json search query "YHlERzzx"
-        Then exactly 0 results are returned
-
-     Scenario: Empty JSONv2 search
-        When sending jsonv2 search query "Flubb XdfESSaZx"
-        Then exactly 0 results are returned
-
-     Scenario: Search for non-existing coordinates
-        When sending json search query "-21.0,-33.0"
-        Then exactly 0 results are returned
-

diff --git a/tests/features/api/search_structured.feature b/tests/features/api/search_structured.feature
deleted file mode 100644 (file)
index 27e5d34..0000000
--- a/tests/features/api/search_structured.feature
+++ /dev/null
@@ -1,41 +0,0 @@
-Feature: Structured search queries
-    Testing correctness of results with
-    structured queries
-
-    Scenario: Country only
-        When sending json structured query with address
-          | country
-          | Canada
-        Then address of result 0 is
-          | type         | value
-          | country      | Canada
-          | country_code | ca
-
-    Scenario: Postcode only
-        When sending json structured query with address
-          | postalcode
-          | 22547
-        Then at least 1 result is returned 
-        And results contain
-          | type
-          | post(al_)?code
-        And result addresses contain
-          | postcode
-          | 22547
-
-
-    Scenario: Street, postcode and country
-        When sending xml structured query with address
-          | street          | postalcode | country
-          | Old Palace Road | GU2 7UP    | United Kingdom
-        Then at least 1 result is returned
-        Then result header contains
-          | attr        | value
-          | querystring | Old Palace Road, GU2 7UP, United Kingdom
-
-
-    Scenario: gihub #176
-        When sending json structured query with address
-          | city
-          | Washington
-        Then at least 1 result is returned

diff --git a/tests/features/db/import/interpolation.feature b/tests/features/db/import/interpolation.feature
deleted file mode 100644 (file)
index 6974e7b..0000000
--- a/tests/features/db/import/interpolation.feature
+++ /dev/null
@@ -1,327 +0,0 @@
-@DB
-Feature: Import of address interpolations
-    Tests that interpolated addresses are added correctly
-
-    Scenario: Simple even interpolation line with two points
-        Given the place nodes
-          | osm_id | osm_type | class | type  | housenumber | geometry
-          | 1      | N        | place | house | 2           | 1 1
-          | 2      | N        | place | house | 6           | 1 1.001
-        And the place ways
-          | osm_id | osm_type | class | type   | housenumber | geometry
-          | 1      | W        | place | houses | even        | 1 1, 1 1.001
-        And the ways
-          | id | nodes
-          | 1  | 1,2
-        When importing
-        Then way 1 expands to lines
-          | startnumber | endnumber | geometry
-          | 2           | 6         | 1 1, 1 1.001
-
-    Scenario: Backwards even two point interpolation line
-        Given the place nodes
-          | osm_id | class | type  | housenumber | geometry
-          | 1      | place | house | 2           | 1 1
-          | 2      | place | house | 6           | 1 1.001
-        And the place ways
-          | osm_id | class | type   | housenumber | geometry
-          | 1      | place | houses | even        | 1 1.001, 1 1
-        And the ways
-          | id | nodes
-          | 1  | 2,1
-        When importing
-        Then way 1 expands to lines
-          | startnumber | endnumber | geometry
-          | 2           | 6         | 1 1, 1 1.001
-
-      Scenario: Simple odd two point interpolation
-        Given the place nodes
-          | osm_id | class | type  | housenumber | geometry
-          | 1      | place | house | 1           | 1 1
-          | 2      | place | house | 11          | 1 1.001
-        And the place ways
-          | osm_id | class | type   | housenumber | geometry
-          | 1      | place | houses | odd         | 1 1, 1 1.001
-        And the ways
-          | id | nodes
-          | 1  | 1,2
-        When importing
-        Then way 1 expands to lines
-          | startnumber | endnumber | geometry
-          | 1           | 11        | 1 1, 1 1.001
-
-     Scenario: Simple all two point interpolation
-        Given the place nodes
-          | osm_id | class | type  | housenumber | geometry
-          | 1      | place | house | 1           | 1 1
-          | 2      | place | house | 3           | 1 1.001
-        And the place ways
-          | osm_id | class | type   | housenumber | geometry
-          | 1      | place | houses | all         | 1 1, 1 1.001
-        And the ways
-          | id | nodes
-          | 1  | 1,2
-        When importing
-        Then way 1 expands to lines
-          | startnumber | endnumber | geometry
-          | 1           | 3         | 1 1, 1 1.001
-
-    Scenario: Even two point interpolation line with intermediate empty node
-        Given the place nodes
-          | osm_id | class | type  | housenumber | geometry
-          | 1      | place | house | 2           | 1 1
-          | 2      | place | house | 10          | 1.001 1.001
-        And the place ways
-          | osm_id | class | type   | housenumber | geometry
-          | 1      | place | houses | even        | 1 1, 1 1.001, 1.001 1.001
-        And the ways
-          | id | nodes
-          | 1  | 1,3,2
-        When importing
-        Then way 1 expands to lines
-          | startnumber | endnumber | geometry
-          | 2           | 10         | 1 1, 1 1.001, 1.001 1.001
-
-    Scenario: Even two point interpolation line with intermediate duplicated empty node
-        Given the place nodes
-          | osm_id | class | type  | housenumber | geometry
-          | 1      | place | house | 2           | 1 1
-          | 2      | place | house | 10          | 1.001 1.001
-        And the place ways
-          | osm_id | class | type   | housenumber | geometry
-          | 1      | place | houses | even        | 1 1, 1 1.001, 1.001 1.001
-        And the ways
-          | id | nodes
-          | 1  | 1,3,3,2
-        When importing
-        Then way 1 expands to lines
-          | startnumber | endnumber | geometry
-          | 2           | 10         | 1 1, 1 1.001, 1.001 1.001
-
-    Scenario: Simple even three point interpolation line
-        Given the place nodes
-          | osm_id | class | type  | housenumber | geometry
-          | 1      | place | house | 2           | 1 1
-          | 2      | place | house | 14          | 1.001 1.001
-          | 3      | place | house | 10          | 1 1.001
-        And the place ways
-          | osm_id | class | type   | housenumber | geometry
-          | 1      | place | houses | even        | 1 1, 1 1.001, 1.001 1.001
-        And the ways
-          | id | nodes
-          | 1  | 1,3,2
-        When importing
-        Then way 1 expands to lines
-          | startnumber | endnumber | geometry
-          | 2           | 10        | 1 1, 1 1.001
-          | 10          | 14        | 1 1.001, 1.001 1.001
-
-     Scenario: Simple even four point interpolation line
-        Given the place nodes
-          | osm_id | class | type  | housenumber | geometry
-          | 1      | place | house | 2           | 1 1
-          | 2      | place | house | 14          | 1.001 1.001
-          | 3      | place | house | 10          | 1 1.001
-          | 4      | place | house | 18          | 1.001 1.002
-        And the place ways
-          | osm_id | class | type   | housenumber | geometry
-          | 1      | place | houses | even        | 1 1, 1 1.001, 1.001 1.001, 1.001 1.002
-        And the ways
-          | id | nodes
-          | 1  | 1,3,2,4
-        When importing
-        Then way 1 expands to lines
-          | startnumber | endnumber | geometry
-          | 2           | 10        | 1 1, 1 1.001
-          | 10          | 14        | 1 1.001, 1.001 1.001
-          | 14          | 18        | 1.001 1.001, 1.001 1.002
-
-    Scenario: Reverse simple even three point interpolation line
-        Given the place nodes
-          | osm_id | class | type  | housenumber | geometry
-          | 1      | place | house | 2           | 1 1
-          | 2      | place | house | 14          | 1.001 1.001
-          | 3      | place | house | 10          | 1 1.001
-        And the place ways
-          | osm_id | class | type   | housenumber | geometry
-          | 1      | place | houses | even        | 1.001 1.001, 1 1.001, 1 1
-        And the ways
-          | id | nodes
-          | 1  | 2,3,1
-        When importing
-        Then way 1 expands to lines
-          | startnumber | endnumber | geometry
-          | 2           | 10        | 1 1, 1 1.001
-          | 10          | 14        | 1 1.001, 1.001 1.001
-
-    Scenario: Even three point interpolation line with odd center point
-        Given the place nodes
-          | osm_id | class | type  | housenumber | geometry
-          | 1      | place | house | 2           | 1 1
-          | 2      | place | house | 8           | 1.001 1.001
-          | 3      | place | house | 7           | 1 1.001
-        And the place ways
-          | osm_id | class | type   | housenumber | geometry
-          | 1      | place | houses | even        | 1 1, 1 1.001, 1.001 1.001
-        And the ways
-          | id | nodes
-          | 1  | 1,3,2
-        When importing
-        Then way 1 expands to lines
-          | startnumber | endnumber | geometry
-          | 2           | 7         | 1 1, 1 1.001
-          | 7           | 8         | 1 1.001, 1.001 1.001
-
-    Scenario: Interpolation line with self-intersecting way
-        Given the place nodes
-          | osm_id | class | type  | housenumber | geometry
-          | 1      | place | house | 2           | 0 0
-          | 2      | place | house | 6           | 0 0.001
-          | 3      | place | house | 10          | 0 0.002
-        And the place ways
-          | osm_id | class | type   | housenumber | geometry
-          | 1      | place | houses | even        | 0 0, 0 0.001, 0 0.002, 0 0.001
-        And the ways
-          | id | nodes
-          | 1  | 1,2,3,2
-        When importing
-        Then way 1 expands to lines
-          | startnumber | endnumber | geometry
-          | 2           | 6         | 0 0, 0 0.001
-          | 6           | 10        | 0 0.001, 0 0.002
-          | 6           | 10        | 0 0.001, 0 0.002
-
-    Scenario: Interpolation line with self-intersecting way II
-        Given the place nodes
-          | osm_id | class | type  | housenumber | geometry
-          | 1      | place | house | 2           | 0 0
-          | 2      | place | house | 6           | 0 0.001
-        And the place ways
-          | osm_id | class | type   | housenumber | geometry
-          | 1      | place | houses | even        | 0 0, 0 0.001, 0 0.002, 0 0.001
-        And the ways
-          | id | nodes
-          | 1  | 1,2,3,2
-        When importing
-        Then way 1 expands to lines
-          | startnumber | endnumber | geometry
-          | 2           | 6         | 0 0, 0 0.001
-
-    Scenario: addr:street on interpolation way
-        Given the scene parallel-road
-        And the place nodes
-          | osm_id | class | type  | housenumber | geometry
-          | 1      | place | house | 2           | :n-middle-w
-          | 2      | place | house | 6           | :n-middle-e
-          | 3      | place | house | 12          | :n-middle-w
-          | 4      | place | house | 16          | :n-middle-e
-        And the place ways
-          | osm_id | class   | type    | housenumber | street       | geometry
-          | 10     | place   | houses  | even        |              | :w-middle
-          | 11     | place   | houses  | even        | Cloud Street | :w-middle
-        And the place ways
-          | osm_id | class   | type     | name                    | geometry
-          | 2      | highway | tertiary | 'name' : 'Sun Way'      | :w-north
-          | 3      | highway | tertiary | 'name' : 'Cloud Street' | :w-south
-        And the ways
-          | id | nodes
-          | 10  | 1,100,101,102,2
-          | 11  | 3,200,201,202,4
-        When importing
-        Then table placex contains
-          | object | parent_place_id
-          | N1     | W2
-          | N2     | W2
-          | N3     | W3
-          | N4     | W3
-        Then table location_property_osmline contains
-          | object | parent_place_id | startnumber | endnumber
-          | W10    | W2              | 2           | 6
-          | W11    | W3              | 12          | 16
-        When sending query "16 Cloud Street"
-        Then results contain
-         | ID | osm_type | osm_id
-         | 0  | N        | 4
-        When sending query "14 Cloud Street"
-        Then results contain
-         | ID | osm_type | osm_id
-         | 0  | W        | 11
-        When sending query "18 Cloud Street"
-        Then results contain
-         | ID | osm_type | osm_id
-         | 0  | W        | 3
-
-    Scenario: addr:street on housenumber way
-        Given the scene parallel-road
-        And the place nodes
-          | osm_id | class | type  | housenumber | street       | geometry
-          | 1      | place | house | 2           |              | :n-middle-w
-          | 2      | place | house | 6           |              | :n-middle-e
-          | 3      | place | house | 12          | Cloud Street | :n-middle-w
-          | 4      | place | house | 16          | Cloud Street | :n-middle-e
-        And the place ways
-          | osm_id | class   | type    | housenumber | geometry
-          | 10     | place   | houses  | even        | :w-middle
-          | 11     | place   | houses  | even        | :w-middle
-        And the place ways
-          | osm_id | class   | type     | name                    | geometry
-          | 2      | highway | tertiary | 'name' : 'Sun Way'      | :w-north
-          | 3      | highway | tertiary | 'name' : 'Cloud Street' | :w-south
-        And the ways
-          | id  | nodes
-          | 10  | 1,100,101,102,2
-          | 11  | 3,200,201,202,4
-        When importing
-        Then table placex contains
-          | object | parent_place_id
-          | N1     | W2
-          | N2     | W2
-          | N3     | W3
-          | N4     | W3
-        And table location_property_osmline contains
-          | object | parent_place_id | startnumber | endnumber
-          | W10    | W2              | 2           | 6
-          | W11    | W3              | 12          | 16
-        When sending query "16 Cloud Street"
-        Then results contain
-         | ID | osm_type | osm_id
-         | 0  | N        | 4
-        When sending query "14 Cloud Street"
-        Then results contain
-         | ID | osm_type | osm_id
-         | 0  | W        | 11
-
-    Scenario: Geometry of points and way don't match (github #253)
-        Given the place nodes
-          | osm_id | class | type   | housenumber | geometry
-          | 1      | place | house  | 10          | 144.9632341 -37.76163
-          | 2      | place | house  | 6           | 144.9630541 -37.7628174
-          | 3      | shop  | supermarket | 2      | 144.9629794 -37.7630755
-        And the place ways
-          | osm_id | class | type   | housenumber | geometry
-          | 1      | place | houses | even        | 144.9632341 -37.76163,144.9630541 -37.7628172,144.9629794 -37.7630755
-        And the ways
-          | id | nodes
-          | 1  | 1,2,3
-        When importing
-        Then way 1 expands to lines
-          | startnumber | endnumber | geometry
-          | 2           | 6         | 144.9629794 -37.7630755, 144.9630541 -37.7628174
-          | 6           | 10        | 144.9630541 -37.7628174, 144.9632341 -37.76163
-
-    Scenario: Place with missing address information
-        Given the place nodes
-          | osm_id | class   | type   | housenumber | geometry
-          | 1      | place   | house  | 23          | 0.0001 0.0001
-          | 2      | amenity | school |             | 0.0001 0.0002
-          | 3      | place   | house  | 29          | 0.0001 0.0004
-        And the place ways
-          | osm_id | class | type   | housenumber | geometry
-          | 1      | place | houses | odd         | 0.0001 0.0001,0.0001 0.0002,0.0001 0.0004
-        And the ways
-          | id | nodes
-          | 1  | 1,2,3
-        When importing
-        Then way 1 expands to lines
-          | startnumber | endnumber | geometry
-          | 23          | 29        | 0.0001 0.0001, 0.0001 0.0002, 0.0001 0.0004

diff --git a/tests/features/db/import/linking.feature b/tests/features/db/import/linking.feature
deleted file mode 100644 (file)
index 299087a..0000000
--- a/tests/features/db/import/linking.feature
+++ /dev/null
@@ -1,112 +0,0 @@
-@DB
-Feature: Linking of places
-    Tests for correctly determining linked places
-
-    Scenario: Only address-describing places can be linked
-        Given the scene way-area-with-center
-        And the place areas
-         | osm_type | osm_id | class   | type   | name  | geometry
-         | R        | 13     | landuse | forest | Garbo | :area
-        And the place nodes
-         | osm_id | class   | type | name  | geometry
-         | 256    | natural | peak | Garbo | :inner-C
-        When importing
-        Then table placex contains
-         | object  | linked_place_id
-         | R13     | None
-         | N256    | None
-
-    Scenario: Waterways are linked when in waterway relations
-        Given the scene split-road
-        And the place ways
-         | osm_type | osm_id | class    | type  | name  | geometry
-         | W        | 1      | waterway | river | Rhein | :w-2
-         | W        | 2      | waterway | river | Rhein | :w-3
-         | R        | 13     | waterway | river | Rhein | :w-1 + :w-2 + :w-3
-         | R        | 23     | waterway | river | Limmat| :w-4a
-        And the relations
-         | id | members                          | tags
-         | 13 | R23:tributary,W1,W2:main_stream  | 'type' : 'waterway'
-        When importing
-        Then table placex contains
-         | object | linked_place_id
-         | W1     | R13
-         | W2     | R13
-         | R13    | None
-         | R23    | None
-        When sending query "rhein"
-        Then results contain
-         | osm_type
-         | R
-
-    Scenario: Relations are not linked when in waterway relations
-        Given the scene split-road
-        And the place ways
-         | osm_type | osm_id | class    | type  | name  | geometry
-         | W        | 1      | waterway | river | Rhein | :w-2
-         | W        | 2      | waterway | river | Rhein | :w-3
-         | R        | 1      | waterway | river | Rhein | :w-1 + :w-2 + :w-3
-         | R        | 2      | waterway | river | Limmat| :w-4a
-        And the relations
-         | id | members                          | tags
-         | 1  | R2                               | 'type' : 'waterway'
-        When importing
-        Then table placex contains
-         | object | linked_place_id
-         | W1     | None
-         | W2     | None
-         | R1     | None
-         | R2     | None
-
-    Scenario: Empty waterway relations are handled correctly
-        Given the scene split-road
-        And the place ways
-         | osm_type | osm_id | class    | type  | name  | geometry
-         | R        | 1      | waterway | river | Rhein | :w-1 + :w-2 + :w-3
-        And the relations
-         | id | members                          | tags
-         | 1 |                                  | 'type' : 'waterway'
-        When importing
-        Then table placex contains
-         | object | linked_place_id
-         | R1     | None
-
-    Scenario: Waterways are not linked when waterway types don't match
-        Given the scene split-road
-        And the place ways
-         | osm_type | osm_id | class    | type     | name  | geometry
-         | W        | 1      | waterway | drain    | Rhein | :w-2
-         | R        | 1      | waterway | river    | Rhein | :w-1 + :w-2 + :w-3
-        And the relations
-         | id | members               | tags
-         | 1  | N23,N34,W1,R45        | 'type' : 'multipolygon'
-        When importing
-        Then table placex contains
-         | object | linked_place_id
-         | W1     | None
-         | R1     | None
-        When sending query "rhein"
-        Then results contain
-          | ID | osm_type
-          |  0 | R
-          |  1 | W
-
-    Scenario: Side streams are linked only when they have the same name
-        Given the scene split-road
-        And the place ways
-         | osm_type | osm_id | class    | type  | name   | geometry
-         | W        | 1      | waterway | river | Rhein2 | :w-2
-         | W        | 2      | waterway | river | Rhein  | :w-3
-         | R        | 1      | waterway | river | Rhein  | :w-1 + :w-2 + :w-3
-        And the relations
-         | id | members                           | tags
-         | 1  | W1:side_stream,W2:side_stream     | 'type' : 'waterway'
-        When importing
-        Then table placex contains
-         | object | linked_place_id
-         | W1     | None
-         | W2     | R1
-        When sending query "rhein2"
-        Then results contain
-         | osm_type
-         | W

diff --git a/tests/features/db/import/naming.feature b/tests/features/db/import/naming.feature
deleted file mode 100644 (file)
index 64a3f8b..0000000
--- a/tests/features/db/import/naming.feature
+++ /dev/null
@@ -1,193 +0,0 @@
-@DB
-Feature: Import and search of names
-    Tests all naming related issues: normalisation,
-    abbreviations, internationalisation, etc.
-
-
-    Scenario: Case-insensitivity of search
-        Given the place nodes
-          | osm_id | class | type      | name
-          | 1      | place | locality  | 'name' : 'FooBar'
-        When importing
-        Then table placex contains
-          | object | class  | type     | name
-          | N1     | place  | locality | 'name' : 'FooBar'
-        When sending query "FooBar"
-        Then results contain
-         | ID | osm_type | osm_id
-         | 0  | N        | 1
-        When sending query "foobar"
-        Then results contain
-         | ID | osm_type | osm_id
-         | 0  | N        | 1
-        When sending query "fOObar"
-        Then results contain
-         | ID | osm_type | osm_id
-         | 0  | N        | 1
-        When sending query "FOOBAR"
-        Then results contain
-         | ID | osm_type | osm_id
-         | 0  | N        | 1
-
-    Scenario: Multiple spaces in name
-        Given the place nodes
-          | osm_id | class | type      | name
-          | 1      | place | locality  | 'name' : 'one two  three'
-        When importing
-        When sending query "one two three"
-        Then results contain
-         | ID | osm_type | osm_id
-         | 0  | N        | 1
-        When sending query "one   two three"
-        Then results contain
-         | ID | osm_type | osm_id
-         | 0  | N        | 1
-        When sending query "one two  three"
-        Then results contain
-         | ID | osm_type | osm_id
-         | 0  | N        | 1
-        When sending query "    one two three"
-        Then results contain
-         | ID | osm_type | osm_id
-         | 0  | N        | 1
-
-    Scenario: Special characters in name
-        Given the place nodes
-          | osm_id | class | type      | name
-          | 1      | place | locality  | 'name' : 'Jim-Knopf-Str'
-          | 2      | place | locality  | 'name' : 'Smith/Weston'
-          | 3      | place | locality  | 'name' : 'space mountain'
-          | 4      | place | locality  | 'name' : 'space'
-          | 5      | place | locality  | 'name' : 'mountain'
-        When importing
-        When sending query "Jim-Knopf-Str"
-        Then results contain
-         | ID | osm_type | osm_id
-         | 0  | N        | 1
-        When sending query "Jim Knopf-Str"
-        Then results contain
-         | ID | osm_type | osm_id
-         | 0  | N        | 1
-        When sending query "Jim Knopf Str"
-        Then results contain
-         | ID | osm_type | osm_id
-         | 0  | N        | 1
-        When sending query "Jim/Knopf-Str"
-        Then results contain
-         | ID | osm_type | osm_id
-         | 0  | N        | 1
-        When sending query "Jim-Knopfstr"
-        Then results contain
-         | ID | osm_type | osm_id
-         | 0  | N        | 1
-        When sending query "Smith/Weston"
-        Then results contain
-         | ID | osm_type | osm_id
-         | 0  | N        | 2
-        When sending query "Smith Weston"
-        Then results contain
-         | ID | osm_type | osm_id
-         | 0  | N        | 2
-        When sending query "Smith-Weston"
-        Then results contain
-         | ID | osm_type | osm_id
-         | 0  | N        | 2
-        When sending query "space mountain"
-        Then results contain
-         | ID | osm_type | osm_id
-         | 0  | N        | 3
-        When sending query "space-mountain"
-        Then results contain
-         | ID | osm_type | osm_id
-         | 0  | N        | 3
-        When sending query "space/mountain"
-        Then results contain
-         | ID | osm_type | osm_id
-         | 0  | N        | 3
-        When sending query "space\mountain"
-        Then results contain
-         | ID | osm_type | osm_id
-         | 0  | N        | 3
-        When sending query "space(mountain)"
-        Then results contain
-         | ID | osm_type | osm_id
-         | 0  | N        | 3
-
-    Scenario: No copying name tag if only one name
-        Given the place nodes
-          | osm_id | class | type      | name              | geometry
-          | 1      | place | locality  | 'name' : 'german' | country:de
-        When importing
-        Then table placex contains
-          | object | calculated_country_code |
-          | N1     | de
-        And table placex contains as names for N1
-          | object | k       | v
-          | N1     | name    | german
-
-    Scenario: Copying name tag to default language if it does not exist
-        Given the place nodes
-          | osm_id | class | type      | name                                     | geometry
-          | 1      | place | locality  | 'name' : 'german', 'name:fi' : 'finnish' | country:de
-        When importing
-        Then table placex contains
-          | object | calculated_country_code |
-          | N1     | de
-        And table placex contains as names for N1
-          | k       | v
-          | name    | german
-          | name:fi | finnish
-          | name:de | german
-
-    Scenario: Copying default language name tag to name if it does not exist
-        Given the place nodes
-          | osm_id | class | type      | name                                        | geometry
-          | 1      | place | locality  | 'name:de' : 'german', 'name:fi' : 'finnish' | country:de
-        When importing
-        Then table placex contains
-          | object | calculated_country_code |
-          | N1     | de
-        And table placex contains as names for N1
-          | k       | v
-          | name    | german
-          | name:fi | finnish
-          | name:de | german
-
-    Scenario: Do not overwrite default language with name tag
-        Given the place nodes
-          | osm_id | class | type      | name                                                          | geometry
-          | 1      | place | locality  | 'name' : 'german', 'name:fi' : 'finnish', 'name:de' : 'local' | country:de
-        When importing
-        Then table placex contains
-          | object | calculated_country_code |
-          | N1     | de
-        And table placex contains as names for N1
-          | k       | v
-          | name    | german
-          | name:fi | finnish
-          | name:de | local
-
-    Scenario: Landuse with name are found
-        Given the place areas
-          | osm_type | osm_id | class    | type        | name                | geometry
-          | R        | 1      | natural  | meadow      | 'name' : 'landuse1' | (0 0, 1 0, 1 1, 0 1, 0 0)
-          | R        | 2      | landuse  | industrial  | 'name' : 'landuse2' | (0 0, -1 0, -1 -1, 0 -1, 0 0)
-        When importing
-        When sending query "landuse1"
-        Then results contain
-         | ID | osm_type | osm_id
-         | 0  | R        | 1
-        When sending query "landuse2"
-        Then results contain
-         | ID | osm_type | osm_id
-         | 0  | R        | 2
-
-    Scenario: Postcode boundaries without ref
-        Given the place areas
-          | osm_type | osm_id | class    | type        | postcode | geometry
-          | R        | 1      | boundary | postal_code | 12345    | (0 0, 1 0, 1 1, 0 1, 0 0)
-        When importing
-        When sending query "12345"
-        Then results contain
-         | ID | osm_type | osm_id
-         | 0  | R        | 1

diff --git a/tests/features/db/import/parenting.feature b/tests/features/db/import/parenting.feature
deleted file mode 100644 (file)
index 36754f8..0000000
--- a/tests/features/db/import/parenting.feature
+++ /dev/null
@@ -1,458 +0,0 @@
-@DB
-Feature: Parenting of objects
-    Tests that the correct parent is choosen
-
-    Scenario: Address inherits postcode from its street unless it has a postcode
-        Given the scene roads-with-pois
-        And the place nodes
-         | osm_id | class | type  | housenumber | geometry
-         | 1      | place | house | 4           | :p-N1
-        And the place nodes
-         | osm_id | class | type  | housenumber | postcode | geometry
-         | 2      | place | house | 5           | 99999    | :p-N1
-        And the place ways
-         | osm_id | class   | type        | name  | postcode | geometry
-         | 1      | highway | residential | galoo | 12345    | :w-north
-        When importing
-        Then table placex contains
-         | object | parent_place_id
-         | N1     | W1
-         | N2     | W1
-        When sending query "4 galoo"
-        Then results contain
-         | ID | osm_type | osm_id | langaddress
-         | 0  | N        | 1      | 4, galoo, 12345
-        When sending query "5 galoo"
-        Then results contain
-         | ID | osm_type | osm_id | langaddress
-         | 0  | N        | 2      | 5, galoo, 99999
-
-
-    Scenario: Address without tags, closest street
-        Given the scene roads-with-pois
-        And the place nodes
-         | osm_id | class | type  | geometry
-         | 1      | place | house | :p-N1
-         | 2      | place | house | :p-N2
-         | 3      | place | house | :p-S1
-         | 4      | place | house | :p-S2
-        And the named place ways
-         | osm_id | class   | type        | geometry
-         | 1      | highway | residential | :w-north
-         | 2      | highway | residential | :w-south
-        When importing
-        Then table placex contains
-         | object | parent_place_id
-         | N1     | W1
-         | N2     | W1
-         | N3     | W2
-         | N4     | W2
-
-    Scenario: Address without tags avoids unnamed streets
-        Given the scene roads-with-pois
-        And the place nodes
-         | osm_id | class | type  | geometry
-         | 1      | place | house | :p-N1
-         | 2      | place | house | :p-N2
-         | 3      | place | house | :p-S1
-         | 4      | place | house | :p-S2
-        And the place ways
-         | osm_id | class   | type        | geometry
-         | 1      | highway | residential | :w-north
-        And the named place ways
-         | osm_id | class   | type        | geometry
-         | 2      | highway | residential | :w-south
-        When importing
-        Then table placex contains
-         | object | parent_place_id
-         | N1     | W2
-         | N2     | W2
-         | N3     | W2
-         | N4     | W2
-
-    Scenario: addr:street tag parents to appropriately named street
-        Given the scene roads-with-pois
-        And the place nodes
-         | osm_id | class | type  | street| geometry
-         | 1      | place | house | south | :p-N1
-         | 2      | place | house | north | :p-N2
-         | 3      | place | house | south | :p-S1
-         | 4      | place | house | north | :p-S2
-        And the place ways
-         | osm_id | class   | type        | name  | geometry
-         | 1      | highway | residential | north | :w-north
-         | 2      | highway | residential | south | :w-south
-        When importing
-        Then table placex contains
-         | object | parent_place_id
-         | N1     | W2
-         | N2     | W1
-         | N3     | W2
-         | N4     | W1
-
-    Scenario: addr:street tag parents to next named street
-        Given the scene roads-with-pois
-        And the place nodes
-         | osm_id | class | type  | street | geometry
-         | 1      | place | house | abcdef | :p-N1
-         | 2      | place | house | abcdef | :p-N2
-         | 3      | place | house | abcdef | :p-S1
-         | 4      | place | house | abcdef | :p-S2
-        And the place ways
-         | osm_id | class   | type        | name   | geometry
-         | 1      | highway | residential | abcdef | :w-north
-         | 2      | highway | residential | abcdef | :w-south
-        When importing
-        Then table placex contains
-         | object | parent_place_id
-         | N1     | W1
-         | N2     | W1
-         | N3     | W2
-         | N4     | W2
-
-    Scenario: addr:street tag without appropriately named street
-        Given the scene roads-with-pois
-        And the place nodes
-         | osm_id | class | type  | street | geometry
-         | 1      | place | house | abcdef | :p-N1
-         | 2      | place | house | abcdef | :p-N2
-         | 3      | place | house | abcdef | :p-S1
-         | 4      | place | house | abcdef | :p-S2
-        And the place ways
-         | osm_id | class   | type        | name  | geometry
-         | 1      | highway | residential | abcde | :w-north
-         | 2      | highway | residential | abcde | :w-south
-        When importing
-        Then table placex contains
-         | object | parent_place_id
-         | N1     | W1
-         | N2     | W1
-         | N3     | W2
-         | N4     | W2
-
-    Scenario: addr:place address
-        Given the scene road-with-alley
-        And the place nodes
-         | osm_id | class | type   | addr_place | geometry
-         | 1      | place | house  | myhamlet   | :n-alley
-        And the place nodes
-         | osm_id | class | type   | name     | geometry
-         | 2      | place | hamlet | myhamlet | :n-main-west
-        And the place ways
-         | osm_id | class   | type        | name     | geometry
-         | 1      | highway | residential | myhamlet | :w-main
-        When importing
-        Then table placex contains
-         | object | parent_place_id
-         | N1     | N2
-
-    Scenario: addr:street is preferred over addr:place
-        Given the scene road-with-alley
-        And the place nodes
-         | osm_id | class | type   | addr_place | street  | geometry
-         | 1      | place | house  | myhamlet   | mystreet| :n-alley
-        And the place nodes
-         | osm_id | class | type   | name     | geometry
-         | 2      | place | hamlet | myhamlet | :n-main-west
-        And the place ways
-         | osm_id | class   | type        | name     | geometry
-         | 1      | highway | residential | mystreet | :w-main
-        When importing
-        Then table placex contains
-         | object | parent_place_id
-         | N1     | W1
-
-     Scenario: Untagged address in simple associated street relation
-        Given the scene road-with-alley
-        And the place nodes
-         | osm_id | class | type  | geometry
-         | 1      | place | house | :n-alley
-         | 2      | place | house | :n-corner
-         | 3      | place | house | :n-main-west
-        And the place ways
-         | osm_id | class   | type        | name | geometry
-         | 1      | highway | residential | foo  | :w-main
-         | 2      | highway | service     | bar  | :w-alley
-        And the relations
-         | id | members            | tags
-         | 1  | W1:street,N1,N2,N3 | 'type' : 'associatedStreet'
-        When importing
-        Then table placex contains
-         | object | parent_place_id
-         | N1     | W1
-         | N2     | W1
-         | N3     | W1
-         
-    Scenario: Avoid unnamed streets in simple associated street relation
-        Given the scene road-with-alley
-        And the place nodes
-         | osm_id | class | type  | geometry
-         | 1      | place | house | :n-alley
-         | 2      | place | house | :n-corner
-         | 3      | place | house | :n-main-west
-        And the named place ways
-         | osm_id | class   | type        | geometry
-         | 1      | highway | residential | :w-main
-        And the place ways
-         | osm_id | class   | type        | geometry
-         | 2      | highway | residential | :w-alley
-        And the relations
-         | id | members            | tags
-         | 1  | N1,N2,N3,W2:street,W1:street | 'type' : 'associatedStreet'
-        When importing
-        Then table placex contains
-         | object | parent_place_id
-         | N1     | W1
-         | N2     | W1
-         | N3     | W1
-
-    ### Scenario 10
-    Scenario: Associated street relation overrides addr:street
-        Given the scene road-with-alley
-        And the place nodes
-         | osm_id | class | type  | street | geometry
-         | 1      | place | house | bar    | :n-alley
-        And the place ways
-         | osm_id | class   | type        | name | geometry
-         | 1      | highway | residential | foo  | :w-main
-         | 2      | highway | residential | bar  | :w-alley
-        And the relations
-         | id | members            | tags
-         | 1  | W1:street,N1,N2,N3 | 'type' : 'associatedStreet'
-        When importing
-        Then table placex contains
-         | object | parent_place_id
-         | N1     | W1
-
-    Scenario: Building without tags, closest street from center point
-        Given the scene building-on-street-corner
-        And the named place ways
-         | osm_id | class    | type        | geometry
-         | 1      | building | yes         | :w-building
-         | 2      | highway  | primary     | :w-WE
-         | 3      | highway  | residential | :w-NS
-        When importing
-        Then table placex contains
-         | object | parent_place_id
-         | W1     | W3
-
-    Scenario: Building with addr:street tags
-        Given the scene building-on-street-corner
-        And the named place ways
-         | osm_id | class    | type | street | geometry
-         | 1      | building | yes  | bar    | :w-building
-        And the place ways
-         | osm_id | class    | type        | name | geometry
-         | 2      | highway  | primary     | bar  | :w-WE
-         | 3      | highway  | residential | foo  | :w-NS
-        When importing
-        Then table placex contains
-         | object | parent_place_id
-         | W1     | W2
-
-    Scenario: Building with addr:place tags
-        Given the scene building-on-street-corner
-        And the place nodes
-         | osm_id | class | type    | name | geometry
-         | 1      | place | village | bar  | :n-outer
-        And the named place ways
-         | osm_id | class    | type | addr_place | geometry
-         | 1      | building | yes  | bar        | :w-building
-        And the place ways
-         | osm_id | class    | type        | name | geometry
-         | 2      | highway  | primary     | bar  | :w-WE
-         | 3      | highway  | residential | foo  | :w-NS
-        When importing
-        Then table placex contains
-         | object | parent_place_id
-         | W1     | N1
-
-    Scenario: Building in associated street relation
-        Given the scene building-on-street-corner
-        And the named place ways
-         | osm_id | class    | type | geometry
-         | 1      | building | yes  | :w-building
-        And the place ways
-         | osm_id | class    | type        | name | geometry
-         | 2      | highway  | primary     | bar  | :w-WE
-         | 3      | highway  | residential | foo  | :w-NS
-        And the relations
-         | id | members            | tags
-         | 1  | W1:house,W2:street | 'type' : 'associatedStreet'
-        When importing
-        Then table placex contains
-         | object | parent_place_id
-         | W1     | W2
-
-    Scenario: Building in associated street relation overrides addr:street
-        Given the scene building-on-street-corner
-        And the named place ways
-         | osm_id | class    | type | street | geometry
-         | 1      | building | yes  | foo    | :w-building
-        And the place ways
-         | osm_id | class    | type        | name | geometry
-         | 2      | highway  | primary     | bar  | :w-WE
-         | 3      | highway  | residential | foo  | :w-NS
-        And the relations
-         | id | members            | tags
-         | 1  | W1:house,W2:street | 'type' : 'associatedStreet'
-        When importing
-        Then table placex contains
-         | object | parent_place_id
-         | W1     | W2
-
-    Scenario: Wrong member in associated street relation is ignored
-        Given the scene building-on-street-corner
-        And the named place nodes
-         | osm_id | class | type  | geometry
-         | 1      | place | house | :n-outer
-        And the named place ways
-         | osm_id | class    | type | street | geometry
-         | 1      | building | yes  | foo    | :w-building
-        And the place ways
-         | osm_id | class    | type        | name | geometry
-         | 2      | highway  | primary     | bar  | :w-WE
-         | 3      | highway  | residential | foo  | :w-NS
-        And the relations
-         | id | members                      | tags
-         | 1  | N1:house,W1:street,W3:street | 'type' : 'associatedStreet'
-        When importing
-        Then table placex contains
-         | object | parent_place_id
-         | N1     | W3
-
-    Scenario: POIs in building inherit address
-        Given the scene building-on-street-corner
-        And the named place nodes
-         | osm_id | class   | type       | geometry
-         | 1      | amenity | bank       | :n-inner
-         | 2      | shop    | bakery     | :n-edge-NS
-         | 3      | shop    | supermarket| :n-edge-WE
-        And the place ways
-         | osm_id | class    | type | street | addr_place | housenumber | geometry
-         | 1      | building | yes  | foo    | nowhere    | 3           | :w-building
-        And the place ways
-         | osm_id | class    | type        | name | geometry
-         | 2      | highway  | primary     | bar  | :w-WE
-         | 3      | highway  | residential | foo  | :w-NS
-        When importing
-        Then table placex contains
-         | object | parent_place_id | street | addr_place | housenumber
-         | W1     | W3              | foo    | nowhere    | 3
-         | N1     | W3              | foo    | nowhere    | 3
-         | N2     | W3              | foo    | nowhere    | 3
-         | N3     | W3              | foo    | nowhere    | 3
-
-    Scenario: POIs don't inherit from streets
-        Given the scene building-on-street-corner
-        And the named place nodes
-         | osm_id | class   | type       | geometry
-         | 1      | amenity | bank       | :n-inner
-        And the place ways
-         | osm_id | class    | type | street | addr_place | housenumber | geometry
-         | 1      | highway  | path | foo    | nowhere    | 3           | :w-building
-        And the place ways
-         | osm_id | class    | type        | name | geometry
-         | 3      | highway  | residential | foo  | :w-NS
-        When importing
-        Then table placex contains
-         | object | parent_place_id | street | addr_place | housenumber
-         | N1     | W3              | None   | None       | None
-
-    Scenario: POIs with own address do not inherit building address
-        Given the scene building-on-street-corner
-        And the named place nodes
-         | osm_id | class   | type       | street | geometry
-         | 1      | amenity | bank       | bar    | :n-inner
-        And the named place nodes
-         | osm_id | class   | type       | housenumber | geometry
-         | 2      | shop    | bakery     | 4           | :n-edge-NS
-        And the named place nodes
-         | osm_id | class   | type       | addr_place  | geometry
-         | 3      | shop    | supermarket| nowhere     | :n-edge-WE
-        And the place nodes
-         | osm_id | class | type              | name     | geometry
-         | 4      | place | isolated_dwelling | theplace | :n-outer
-        And the place ways
-         | osm_id | class    | type | addr_place | housenumber | geometry
-         | 1      | building | yes  | theplace   | 3           | :w-building
-        And the place ways
-         | osm_id | class    | type        | name | geometry
-         | 2      | highway  | primary     | bar  | :w-WE
-         | 3      | highway  | residential | foo  | :w-NS
-        When importing
-        Then table placex contains
-         | object | parent_place_id | street | addr_place | housenumber
-         | W1     | N4              | None   | theplace   | 3
-         | N1     | W2              | bar    | None       | None
-         | N2     | W3              | None   | None       | 4
-         | N3     | W2              | None   | nowhere    | None
-
-    ### Scenario 20
-    Scenario: POIs parent a road if they are attached to it
-        Given the scene points-on-roads
-        And the named place nodes
-         | osm_id | class   | type     | street   | geometry
-         | 1      | highway | bus_stop | North St | :n-SE
-         | 2      | highway | bus_stop | South St | :n-NW
-         | 3      | highway | bus_stop | North St | :n-S-unglued
-         | 4      | highway | bus_stop | South St | :n-N-unglued
-        And the place ways
-         | osm_id | class   | type         | name     | geometry
-         | 1      | highway | secondary    | North St | :w-north
-         | 2      | highway | unclassified | South St | :w-south
-        And the ways
-         | id | nodes
-         | 1  | 100,101,2,103,104
-         | 2  | 200,201,1,202,203
-        When importing
-        Then table placex contains
-         | object | parent_place_id
-         | N1     | W1
-         | N2     | W2
-         | N3     | W1
-         | N4     | W2
-
-    Scenario: POIs do not parent non-roads they are attached to
-        Given the scene points-on-roads
-        And the named place nodes
-         | osm_id | class   | type     | street   | geometry
-         | 1      | highway | bus_stop | North St | :n-SE
-         | 2      | highway | bus_stop | South St | :n-NW
-        And the place ways
-         | osm_id | class   | type         | name     | geometry
-         | 1      | landuse | residential  | North St | :w-north
-         | 2      | waterway| river        | South St | :w-south
-        And the ways
-         | id | nodes
-         | 1  | 100,101,2,103,104
-         | 2  | 200,201,1,202,203
-        When importing
-        Then table placex contains
-         | object | parent_place_id
-         | N1     | 0
-         | N2     | 0
-
-    Scenario: POIs on building outlines inherit associated street relation
-        Given the scene building-on-street-corner
-        And the named place nodes
-         | osm_id | class  | type  | geometry
-         | 1      | place  | house | :n-edge-NS
-        And the named place ways
-         | osm_id | class    | type | geometry
-         | 1      | building | yes  | :w-building
-        And the place ways
-         | osm_id | class    | type        | name | geometry
-         | 2      | highway  | primary     | bar  | :w-WE
-         | 3      | highway  | residential | foo  | :w-NS
-        And the relations
-         | id | members            | tags
-         | 1  | W1:house,W2:street | 'type' : 'associatedStreet'
-        And the ways
-         | id | nodes
-         | 1  | 100,1,101,102,100
-        When importing
-        Then table placex contains
-         | object | parent_place_id
-         | N1     | W2
-

diff --git a/tests/features/db/import/placex.feature b/tests/features/db/import/placex.feature
deleted file mode 100644 (file)
index 95e0bc9..0000000
--- a/tests/features/db/import/placex.feature
+++ /dev/null
@@ -1,318 +0,0 @@
-@DB
-Feature: Import into placex
-    Tests that data in placex is completed correctly.
-
-    Scenario: No country code tag is available
-        Given the place nodes
-          | osm_id | class   | type     | name           | geometry
-          | 1      | highway | primary  | 'name' : 'A1'  | country:us
-        When importing
-        Then table placex contains
-          | object | country_code | calculated_country_code |
-          | N1     | None         | us                      |
-
-    Scenario: Location overwrites country code tag
-        Given the scene country
-        And the place nodes
-          | osm_id | class   | type     | name           | country_code | geometry
-          | 1      | highway | primary  | 'name' : 'A1'  | de           | :us
-        When importing
-        Then table placex contains
-          | object | country_code | calculated_country_code |
-          | N1     | de           | us                      |
-
-    Scenario: Country code tag overwrites location for countries
-        Given the place areas
-          | osm_type | osm_id | class    | type            | admin_level | name            | country_code | geometry
-          | R        | 1      | boundary | administrative  | 2           | 'name' : 'foo'  | de           | (-100 40, -101 40, -101 41, -100 41, -100 40)
-        When importing
-        Then table placex contains
-          | object | country_code | calculated_country_code |
-          | R1     | de           | de                      |
-
-    Scenario: Illegal country code tag for countries is ignored
-        And the place areas
-          | osm_type | osm_id | class    | type            | admin_level | name            | country_code | geometry
-          | R        | 1      | boundary | administrative  | 2           | 'name' : 'foo'  | xx          | (-100 40, -101 40, -101 41, -100 41, -100 40)
-        When importing
-        Then table placex contains
-          | object | country_code | calculated_country_code |
-          | R1     | xx           | us                      |
-
-    Scenario: admin level is copied over
-        Given the place nodes
-          | osm_id | class | type      | admin_level | name
-          | 1      | place | state     | 3           | 'name' : 'foo'
-        When importing
-        Then table placex contains
-          | object | admin_level |
-          | N1     | 3           |
-
-    Scenario: admin level is default 15
-        Given the place nodes
-          | osm_id | class   | type      | name
-          | 1      | amenity | prison    | 'name' : 'foo'
-        When importing
-        Then table placex contains
-          | object | admin_level |
-          | N1     | 15          |
-
-    Scenario: admin level is never larger than 15
-        Given the place nodes
-          | osm_id | class   | type      | name           | admin_level
-          | 1      | amenity | prison    | 'name' : 'foo' | 16
-        When importing
-        Then table placex contains
-          | object | admin_level |
-          | N1     | 15          |
-
-
-    Scenario: postcode node without postcode is dropped
-        Given the place nodes
-          | osm_id | class   | type
-          | 1      | place   | postcode
-        When importing
-        Then table placex has no entry for N1
-
-    Scenario: postcode boundary without postcode is dropped
-        Given the place areas
-          | osm_type | osm_id | class    | type        | geometry
-          | R        | 1      | boundary | postal_code | poly-area:0.1
-        When importing
-        Then table placex has no entry for R1
-
-    Scenario: search and address ranks for GB post codes correctly assigned
-        Given the place nodes
-         | osm_id  | class | type     | postcode | geometry
-         | 1       | place | postcode | E45 2CD  | country:gb
-         | 2       | place | postcode | E45 2    | country:gb
-         | 3       | place | postcode | Y45      | country:gb
-        When importing
-        Then table placex contains
-         | object | postcode | calculated_country_code | rank_search | rank_address
-         | N1     | E45 2CD  | gb                      | 25          | 5
-         | N2     | E45 2    | gb                      | 23          | 5
-         | N3     | Y45      | gb                      | 21          | 5
-
-    Scenario: wrongly formatted GB postcodes are down-ranked
-        Given the place nodes
-         | osm_id  | class | type     | postcode | geometry
-         | 1       | place | postcode | EA452CD  | country:gb
-         | 2       | place | postcode | E45 23   | country:gb
-         | 3       | place | postcode | y45      | country:gb
-        When importing
-        Then table placex contains
-         | object | calculated_country_code | rank_search | rank_address
-         | N1     | gb                      | 30          | 30
-         | N2     | gb                      | 30          | 30
-         | N3     | gb                      | 30          | 30
-
-    Scenario: search and address rank for DE postcodes correctly assigned
-        Given the place nodes
-         | osm_id  | class | type     | postcode | geometry
-         | 1       | place | postcode | 56427    | country:de
-         | 2       | place | postcode | 5642     | country:de
-         | 3       | place | postcode | 5642A    | country:de
-         | 4       | place | postcode | 564276   | country:de
-        When importing
-        Then table placex contains
-         | object | calculated_country_code | rank_search | rank_address
-         | N1     | de                      | 21          | 11
-         | N2     | de                      | 30          | 30
-         | N3     | de                      | 30          | 30
-         | N4     | de                      | 30          | 30
-
-    Scenario: search and address rank for other postcodes are correctly assigned
-        Given the place nodes
-         | osm_id  | class | type     | postcode | geometry
-         | 1       | place | postcode | 1        | country:ca
-         | 2       | place | postcode | X3       | country:ca
-         | 3       | place | postcode | 543      | country:ca
-         | 4       | place | postcode | 54dc     | country:ca
-         | 5       | place | postcode | 12345    | country:ca
-         | 6       | place | postcode | 55TT667  | country:ca
-         | 7       | place | postcode | 123-65   | country:ca
-         | 8       | place | postcode | 12 445 4 | country:ca
-         | 9       | place | postcode | A1:bc10  | country:ca
-        When importing
-        Then table placex contains
-         | object | calculated_country_code | rank_search | rank_address
-         | N1     | ca                      | 21          | 11
-         | N2     | ca                      | 21          | 11
-         | N3     | ca                      | 21          | 11
-         | N4     | ca                      | 21          | 11
-         | N5     | ca                      | 21          | 11
-         | N6     | ca                      | 21          | 11
-         | N7     | ca                      | 25          | 11
-         | N8     | ca                      | 25          | 11
-         | N9     | ca                      | 25          | 11
-
-
-    Scenario: search and address ranks for places are correctly assigned
-        Given the named place nodes
-          | osm_id | class     | type      | 
-          | 1      | foo       | bar       |
-          | 11     | place     | Continent |
-          | 12     | place     | continent |
-          | 13     | place     | sea       |
-          | 14     | place     | country   |
-          | 15     | place     | state     |
-          | 16     | place     | region    |
-          | 17     | place     | county    |
-          | 18     | place     | city      |
-          | 19     | place     | island    |
-          | 20     | place     | town      |
-          | 21     | place     | village   |
-          | 22     | place     | hamlet    |
-          | 23     | place     | municipality |
-          | 24     | place     | district     |
-          | 25     | place     | unincorporated_area |
-          | 26     | place     | borough             |
-          | 27     | place     | suburb              |
-          | 28     | place     | croft               |
-          | 29     | place     | subdivision         |
-          | 30     | place     | isolated_dwelling   |
-          | 31     | place     | farm                |
-          | 32     | place     | locality            |
-          | 33     | place     | islet               |
-          | 34     | place     | mountain_pass       |
-          | 35     | place     | neighbourhood       |
-          | 36     | place     | house               |
-          | 37     | place     | building            |
-          | 38     | place     | houses              |
-        And the named place nodes
-          | osm_id | class     | type      | extratags
-          | 100    | place     | locality  | 'locality' : 'townland'
-          | 101    | place     | city      | 'capital' : 'yes'
-        When importing
-        Then table placex contains
-          | object | rank_search | rank_address |
-          | N1     | 30          | 30 |
-          | N11    | 30          | 30 |
-          | N12    | 2           | 2 |
-          | N13    | 2           | 0 |
-          | N14    | 4           | 4 |
-          | N15    | 8           | 8 |
-          | N16    | 18          | 0 |
-          | N17    | 12          | 12 |
-          | N18    | 16          | 16 |
-          | N19    | 17          | 0 |
-          | N20    | 18          | 16 |
-          | N21    | 19          | 16 |
-          | N22    | 19          | 16 |
-          | N23    | 19          | 16 |
-          | N24    | 19          | 16 |
-          | N25    | 19          | 16 |
-          | N26    | 19          | 16 |
-          | N27    | 20          | 20 |
-          | N28    | 20          | 20 |
-          | N29    | 20          | 20 |
-          | N30    | 20          | 20 |
-          | N31    | 20          | 0 |
-          | N32    | 20          | 0 |
-          | N33    | 20          | 0 |
-          | N34    | 20          | 0 |
-          | N100   | 20          | 20 |
-          | N101   | 15          | 16 |
-          | N35    | 22          | 22 |
-          | N36    | 30          | 30 |
-          | N37    | 30          | 30 |
-          | N38    | 28          | 0 |
-
-    Scenario: search and address ranks for boundaries are correctly assigned
-        Given the named place nodes
-          | osm_id | class    | type
-          | 1      | boundary | administrative
-        And the named place ways
-          | osm_id | class    | type           | geometry
-          | 10     | boundary | administrative | 10 10, 11 11
-        And the named place areas
-          | osm_type | osm_id | class    | type           | admin_level | geometry
-          | R        | 20     | boundary | administrative | 2           | (1 1, 2 2, 1 2, 1 1)
-          | R        | 21     | boundary | administrative | 32          | (3 3, 4 4, 3 4, 3 3)
-          | R        | 22     | boundary | nature_park    | 6           | (0 0, 1 0, 0 1, 0 0)
-          | R        | 23     | boundary | natural_reserve| 10          | (0 0, 1 1, 1 0, 0 0)
-        When importing
-        Then table placex has no entry for N1
-        And table placex has no entry for W10
-        And table placex contains
-          | object | rank_search | rank_address
-          | R20    | 4           | 4
-          | R21    | 30          | 30
-          | R22    | 12          | 0
-          | R23    | 20          | 0
-
-    Scenario: search and address ranks for highways correctly assigned
-        Given the scene roads-with-pois
-        And the place nodes
-          | osm_id | class    | type 
-          | 1      | highway  | bus_stop
-        And the place ways
-          | osm_id | class    | type         | geometry
-          | 1      | highway  | primary      | :w-south
-          | 2      | highway  | secondary    | :w-south
-          | 3      | highway  | tertiary     | :w-south
-          | 4      | highway  | residential  | :w-north
-          | 5      | highway  | unclassified | :w-north
-          | 6      | highway  | something    | :w-north
-        When importing
-        Then table placex contains
-          | object | rank_search | rank_address
-          | N1     | 30          | 30
-          | W1     | 26          | 26
-          | W2     | 26          | 26
-          | W3     | 26          | 26
-          | W4     | 26          | 26
-          | W5     | 26          | 26
-          | W6     | 26          | 26
-
-    Scenario: rank and inclusion of landuses
-        And the named place nodes
-          | osm_id | class   | type
-          | 2      | landuse | residential
-        And the named place ways
-          | osm_id | class   | type        | geometry
-          | 2      | landuse | residential | 1 1, 1 1.1
-        And the named place areas
-          | osm_type | osm_id | class   | type        | geometry
-          | W        | 4      | landuse | residential | poly-area:0.1
-          | R        | 2      | landuse | residential | poly-area:0.05
-          | R        | 3      | landuse | forrest     | poly-area:0.5
-        When importing
-        And table placex contains
-          | object | rank_search | rank_address
-          | N2     | 30          | 30
-          | W2     | 30          | 30
-          | W4     | 22          | 22
-          | R2     | 22          | 22
-          | R3     | 22          | 0
-
-    Scenario: rank and inclusion of naturals
-       And the named place nodes
-          | osm_id | class   | type
-          | 2      | natural | peak
-          | 4      | natural | volcano
-          | 5      | natural | foobar
-       And the named place ways
-          | osm_id | class   | type           | geometry
-          | 2      | natural | mountain_range | 12 12,11 11
-          | 3      | natural | foobar         | 13 13,13.1 13
-       And the named place areas
-          | osm_type | osm_id | class   | type           | geometry
-          | R        | 3      | natural | volcano        | poly-area:0.1
-          | R        | 4      | natural | foobar         | poly-area:0.5
-          | R        | 5      | natural | sea            | poly-area:5.0
-          | R        | 6      | natural | sea            | poly-area:0.01
-       When importing
-       And table placex contains
-          | object | rank_search | rank_address
-          | N2     | 18          | 0
-          | N4     | 18          | 0
-          | N5     | 30          | 30
-          | W2     | 18          | 0
-          | R3     | 18          | 0
-          | R4     | 22          | 0
-          | R5     | 4           | 4
-          | R6     | 4           | 4
-          | W3     | 30          | 30
-

diff --git a/tests/features/db/import/search_terms.feature b/tests/features/db/import/search_terms.feature
deleted file mode 100644 (file)
index f68fe61..0000000
--- a/tests/features/db/import/search_terms.feature
+++ /dev/null
@@ -1,42 +0,0 @@
-@DB
-Feature: Creation of search terms
-    Tests that search_name table is filled correctly
-
-    Scenario: POIs without a name have no search entry
-        Given the scene roads-with-pois
-        And the place nodes
-         | osm_id | class | type  | geometry
-         | 1      | place | house | :p-N1
-        And the place ways
-         | osm_id | class   | type        | geometry
-         | 1      | highway | residential | :w-north
-        When importing
-        Then table search_name has no entry for N1
-
-
-    Scenario: Named POIs inherit address from parent
-        Given the scene roads-with-pois
-        And the place nodes
-         | osm_id | class | type  | name | geometry
-         | 1      | place | house | foo  | :p-N1
-        And the place ways
-         | osm_id | class   | type        | name     | geometry
-         | 1      | highway | residential | the road | :w-north
-        When importing
-        Then search_name table contains
-         | place_id | name_vector | nameaddress_vector
-         | N1       | foo         | the road
-
-    Scenario: Roads take over the postcode from attached houses
-        Given the scene roads-with-pois
-        And the place nodes
-         | osm_id | class | type  | housenumber | postcode | street   | geometry
-         | 1      | place | house | 1           | 12345    | North St |:p-S1
-        And the place ways
-         | osm_id | class   | type        | name     | geometry
-         | 1      | highway | residential | North St | :w-north
-        When importing
-        Then search_name table contains
-         | place_id | nameaddress_vector
-         | W1       | 12345
-

diff --git a/tests/features/db/import/simple.feature b/tests/features/db/import/simple.feature
deleted file mode 100644 (file)
index 2e2c825..0000000
--- a/tests/features/db/import/simple.feature
+++ /dev/null
@@ -1,17 +0,0 @@
-@DB
-Feature: Import of simple objects
-    Testing simple stuff
-
-    Scenario: Import place node
-        Given the place nodes:
-          | osm_id | class | type    | name           | geometry
-          | 1      | place | village | 'name' : 'Foo' | 10.0 -10.0
-        When importing
-        Then table placex contains
-          | object | class  | type    | name           | centroid
-          | N1     | place  | village | 'name' : 'Foo' | 10.0,-10.0 +- 1m
-        When sending query "Foo"
-        Then results contain
-         | ID | osm_type | osm_id
-         | 0  | N        | 1
-

diff --git a/tests/features/db/update/interpolation.feature b/tests/features/db/update/interpolation.feature
deleted file mode 100644 (file)
index 66367b1..0000000
--- a/tests/features/db/update/interpolation.feature
+++ /dev/null
@@ -1,258 +0,0 @@
-@DB
-Feature: Update of address interpolations
-    Test the interpolated address are updated correctly
-
-    Scenario: addr:street added to interpolation
-      Given the scene parallel-road
-      And the place nodes
-          | osm_id | class | type  | housenumber | geometry
-          | 1      | place | house | 2           | :n-middle-w
-          | 2      | place | house | 6           | :n-middle-e
-      And the place ways
-          | osm_id | class   | type    | housenumber | geometry
-          | 10     | place   | houses  | even        | :w-middle
-      And the place ways
-          | osm_id | class   | type         | name                    | geometry
-          | 2      | highway | unclassified | 'name' : 'Sun Way'      | :w-north
-          | 3      | highway | unclassified | 'name' : 'Cloud Street' | :w-south
-      And the ways
-          | id  | nodes
-          | 10  | 1,100,101,102,2
-      When importing
-      Then table placex contains
-          | object | parent_place_id
-          | N1     | W2
-          | N2     | W2
-      And table location_property_osmline contains
-          | object | parent_place_id | startnumber | endnumber
-          | W10    | W2              | 2           | 6
-      When updating place ways
-          | osm_id | class   | type    | housenumber | street       | geometry
-          | 10     | place   | houses  | even        | Cloud Street | :w-middle
-      Then table placex contains
-          | object | parent_place_id
-          | N1     | W3
-          | N2     | W3
-      And table location_property_osmline contains
-          | object | parent_place_id | startnumber | endnumber
-          | W10    | W3              | 2           | 6
-
-    Scenario: addr:street added to housenumbers
-      Given the scene parallel-road
-      And the place nodes
-          | osm_id | class | type  | housenumber | geometry
-          | 1      | place | house | 2           | :n-middle-w
-          | 2      | place | house | 6           | :n-middle-e
-      And the place ways
-          | osm_id | class   | type    | housenumber | geometry
-          | 10     | place   | houses  | even        | :w-middle
-      And the place ways
-          | osm_id | class   | type         | name                    | geometry
-          | 2      | highway | unclassified | 'name' : 'Sun Way'      | :w-north
-          | 3      | highway | unclassified | 'name' : 'Cloud Street' | :w-south
-      And the ways
-          | id  | nodes
-          | 10  | 1,100,101,102,2
-      When importing
-      Then table placex contains
-          | object | parent_place_id
-          | N1     | W2
-          | N2     | W2
-      And table location_property_osmline contains
-          | object | parent_place_id | startnumber | endnumber
-          | W10    | W2              | 2           | 6
-      When updating place nodes
-          | osm_id | class | type  | street      | housenumber | geometry
-          | 1      | place | house | Cloud Street| 2           | :n-middle-w
-          | 2      | place | house | Cloud Street| 6           | :n-middle-e
-      Then table placex contains
-          | object | parent_place_id
-          | N1     | W3
-          | N2     | W3
-      And table location_property_osmline contains
-          | object | parent_place_id | startnumber | endnumber
-          | W10    | W3              | 2           | 6
-
-
-    Scenario: interpolation tag removed
-      Given the scene parallel-road
-      And the place nodes
-          | osm_id | class | type  | housenumber | geometry
-          | 1      | place | house | 2           | :n-middle-w
-          | 2      | place | house | 6           | :n-middle-e
-      And the place ways
-          | osm_id | class   | type    | housenumber | geometry
-          | 10     | place   | houses  | even        | :w-middle
-      And the place ways
-          | osm_id | class   | type         | name                    | geometry
-          | 2      | highway | unclassified | 'name' : 'Sun Way'      | :w-north
-          | 3      | highway | unclassified | 'name' : 'Cloud Street' | :w-south
-      And the ways
-          | id  | nodes
-          | 10  | 1,100,101,102,2
-      When importing
-      Then table placex contains
-          | object | parent_place_id
-          | N1     | W2
-          | N2     | W2
-      And table location_property_osmline contains
-          | object | parent_place_id | startnumber | endnumber
-          | W10    | W2              | 2           | 6
-      When marking for delete W10
-      Then table location_property_osmline has no entry for W10
-      And table placex contains
-          | object | parent_place_id
-          | N1     | W2
-          | N2     | W2
-
-
-    Scenario: referenced road added
-      Given the scene parallel-road
-      And the place nodes
-          | osm_id | class | type  | housenumber | geometry
-          | 1      | place | house | 2           | :n-middle-w
-          | 2      | place | house | 6           | :n-middle-e
-      And the place ways
-          | osm_id | class   | type    | housenumber | street      | geometry
-          | 10     | place   | houses  | even        | Cloud Street| :w-middle
-      And the place ways
-          | osm_id | class   | type         | name                    | geometry
-          | 2      | highway | unclassified | 'name' : 'Sun Way'      | :w-north
-      And the ways
-          | id  | nodes
-          | 10  | 1,100,101,102,2
-      When importing
-      Then table placex contains
-          | object | parent_place_id
-          | N1     | W2
-          | N2     | W2
-      And table location_property_osmline contains
-          | object | parent_place_id | startnumber | endnumber
-          | W10    | W2              | 2           | 6
-      When updating place ways
-          | osm_id | class   | type         | name                    | geometry
-          | 3      | highway | unclassified | 'name' : 'Cloud Street' | :w-south
-      Then table placex contains
-          | object | parent_place_id
-          | N1     | W3
-          | N2     | W3
-      And table location_property_osmline contains
-          | object | parent_place_id | startnumber | endnumber
-          | W10    | W3              | 2           | 6
-
-
-    Scenario: referenced road deleted
-      Given the scene parallel-road
-      And the place nodes
-          | osm_id | class | type  | housenumber | geometry
-          | 1      | place | house | 2           | :n-middle-w
-          | 2      | place | house | 6           | :n-middle-e
-      And the place ways
-          | osm_id | class   | type    | housenumber | street      | geometry
-          | 10     | place   | houses  | even        | Cloud Street| :w-middle
-      And the place ways
-          | osm_id | class   | type         | name                    | geometry
-          | 2      | highway | unclassified | 'name' : 'Sun Way'      | :w-north
-          | 3      | highway | unclassified | 'name' : 'Cloud Street' | :w-south
-      And the ways
-          | id  | nodes
-          | 10  | 1,100,101,102,2
-      When importing
-      Then table placex contains
-          | object | parent_place_id
-          | N1     | W3
-          | N2     | W3
-      And table location_property_osmline contains
-          | object | parent_place_id | startnumber | endnumber
-          | W10    | W3              | 2           | 6
-      When marking for delete W3
-      Then table placex contains
-          | object | parent_place_id
-          | N1     | W2
-          | N2     | W2
-      And table location_property_osmline contains
-          | object | parent_place_id | startnumber | endnumber
-          | W10    | W2              | 2           | 6
-
-    Scenario: building becomes interpolation
-      Given the scene building-with-parallel-streets
-      And the place ways
-          | osm_id | class    | type  | housenumber | geometry
-          | 1      | place    | house | 3           | :w-building
-      And the place ways
-          | osm_id | class   | type         | name                    | geometry
-          | 2      | highway | unclassified | 'name' : 'Cloud Street' | :w-south
-      When importing
-      Then table placex contains
-          | object | parent_place_id
-          | W1     | W2
-      When updating place nodes
-          | osm_id | class | type  | housenumber | geometry
-          | 1      | place | house | 2           | :n-north-w
-          | 2      | place | house | 6           | :n-north-e
-      And the ways
-          | id  | nodes
-          | 1   | 1,100,101,102,2
-      And updating place ways
-          | osm_id | class   | type    | housenumber | street      | geometry
-          | 1      | place   | houses  | even        | Cloud Street| :w-north
-      Then table placex has no entry for W1
-      And table location_property_osmline contains
-          | object | parent_place_id | startnumber | endnumber
-          | W1     | W2              | 2           | 6
-
-
-
-    Scenario: interpolation becomes building
-      Given the scene building-with-parallel-streets
-      And the place nodes
-          | osm_id | class | type  | housenumber | geometry
-          | 1      | place | house | 2           | :n-north-w
-          | 2      | place | house | 6           | :n-north-e
-      And the place ways
-          | osm_id | class   | type         | name                    | geometry
-          | 2      | highway | unclassified | 'name' : 'Cloud Street' | :w-south
-      And the ways
-          | id  | nodes
-          | 1   | 1,100,101,102,2
-      And the place ways
-          | osm_id | class   | type    | housenumber | street      | geometry
-          | 1      | place   | houses  | even        | Cloud Street| :w-north
-      When importing
-      Then table placex has no entry for W1
-      And table location_property_osmline contains
-          | object | parent_place_id | startnumber | endnumber
-          | W1     | W2              | 2           | 6
-      When updating place ways
-          | osm_id | class    | type  | housenumber | geometry
-          | 1      | place    | house | 3           | :w-building
-      Then table placex contains
-          | object | parent_place_id
-          | W1     | W2
-
-    Scenario: housenumbers added to interpolation
-      Given the scene building-with-parallel-streets
-      And the place ways
-          | osm_id | class   | type         | name                    | geometry
-          | 2      | highway | unclassified | 'name' : 'Cloud Street' | :w-south
-      And the ways
-          | id  | nodes
-          | 1   | 1,100,101,102,2
-      And the place ways
-          | osm_id | class   | type    | housenumber | geometry
-          | 1      | place   | houses  | even        | :w-north
-      When importing
-      Then table location_property_osmline has no entry for W1
-      When updating place nodes
-          | osm_id | class | type  | housenumber | geometry
-          | 1      | place | house | 2           | :n-north-w
-          | 2      | place | house | 6           | :n-north-e
-      And updating place ways
-          | osm_id | class   | type    | housenumber | street      | geometry
-          | 1      | place   | houses  | even        | Cloud Street| :w-north
-      Then table location_property_osmline contains
-          | object | parent_place_id | startnumber | endnumber
-          | W1     | W2              | 2           | 6
-
-
-

diff --git a/tests/features/db/update/linked_places.feature b/tests/features/db/update/linked_places.feature
deleted file mode 100644 (file)
index 777a02f..0000000
--- a/tests/features/db/update/linked_places.feature
+++ /dev/null
@@ -1,96 +0,0 @@
-@DB
-Feature: Updates of linked places
-    Tests that linked places are correctly added and deleted.
-    
-
-    Scenario: Add linked place when linking relation is renamed
-        Given the place nodes
-            | osm_id | class | type | name | geometry
-            | 1      | place | city | foo  | 0 0
-        And the place areas
-            | osm_type | osm_id | class    | type           | name | admin_level | geometry
-            | R        | 1      | boundary | administrative | foo  | 8           | poly-area:0.1
-        When importing
-        And sending query "foo" with dups
-        Then results contain
-         | osm_type
-         | R
-        When updating place areas
-         | osm_type | osm_id | class    | type           | name   | admin_level | geometry
-         | R        | 1      | boundary | administrative | foobar | 8           | poly-area:0.1
-        Then table placex contains
-         | object | linked_place_id
-         | N1     | None
-        When updating place areas
-         | osm_type | osm_id | class    | type           | name   | admin_level | geometry
-        When sending query "foo" with dups
-        Then results contain
-         | osm_type
-         | N
-
-    Scenario: Add linked place when linking relation is removed
-        Given the place nodes
-            | osm_id | class | type | name | geometry
-            | 1      | place | city | foo  | 0 0
-        And the place areas
-            | osm_type | osm_id | class    | type           | name | admin_level | geometry
-            | R        | 1      | boundary | administrative | foo  | 8           | poly-area:0.1
-        When importing
-        And sending query "foo" with dups
-        Then results contain
-         | osm_type
-         | R
-        When marking for delete R1
-        Then table placex contains
-         | object | linked_place_id
-         | N1     | None
-        When updating place areas
-         | osm_type | osm_id | class    | type           | name   | admin_level | geometry
-        And sending query "foo" with dups
-        Then results contain
-         | osm_type
-         | N
-
-    Scenario: Remove linked place when linking relation is added
-        Given the place nodes
-            | osm_id | class | type | name | geometry
-            | 1      | place | city | foo  | 0 0
-        When importing
-        And sending query "foo" with dups
-        Then results contain
-         | osm_type
-         | N
-        When updating place areas
-         | osm_type | osm_id | class    | type           | name   | admin_level | geometry
-         | R        | 1      | boundary | administrative | foo    | 8           | poly-area:0.1
-        Then table placex contains
-         | object | linked_place_id
-         | N1     | R1
-        When sending query "foo" with dups
-        Then results contain
-         | osm_type
-         | R
-
-    Scenario: Remove linked place when linking relation is renamed
-        Given the place nodes
-            | osm_id | class | type | name | geometry
-            | 1      | place | city | foo  | 0 0
-        And the place areas
-         | osm_type | osm_id | class    | type           | name   | admin_level | geometry
-         | R        | 1      | boundary | administrative | foobar | 8           | poly-area:0.1
-        When importing
-        And sending query "foo" with dups
-        Then results contain
-         | osm_type
-         | N
-        When updating place areas
-         | osm_type | osm_id | class    | type           | name   | admin_level | geometry
-         | R        | 1      | boundary | administrative | foo    | 8           | poly-area:0.1
-        Then table placex contains
-         | object | linked_place_id
-         | N1     | R1
-        When sending query "foo" with dups
-        Then results contain
-         | osm_type
-         | R
-

diff --git a/tests/features/db/update/naming.feature b/tests/features/db/update/naming.feature
deleted file mode 100644 (file)
index 261f02d..0000000
--- a/tests/features/db/update/naming.feature
+++ /dev/null
@@ -1,39 +0,0 @@
-@DB
-Feature: Update of names in place objects
-    Test all naming related issues in updates
-
-
-    Scenario: Updating postcode in postcode boundaries without ref
-        Given the place areas
-          | osm_type | osm_id | class    | type        | postcode | geometry
-          | R        | 1      | boundary | postal_code | 12345    | (0 0, 1 0, 1 1, 0 1, 0 0)
-        When importing
-        And sending query "12345"
-        Then results contain
-         | ID | osm_type | osm_id
-         | 0  | R        | 1
-        When updating place areas
-          | osm_type | osm_id | class    | type        | postcode | geometry
-          | R        | 1      | boundary | postal_code | 54321    | (0 0, 1 0, 1 1, 0 1, 0 0)
-        And sending query "12345"
-        Then exactly 0 results are returned
-        When sending query "54321"
-        Then results contain
-         | ID | osm_type | osm_id
-         | 0  | R        | 1
-
-
-    Scenario: Delete postcode from postcode boundaries without ref
-        Given the place areas
-          | osm_type | osm_id | class    | type        | postcode | geometry
-          | R        | 1      | boundary | postal_code | 12345    | (0 0, 1 0, 1 1, 0 1, 0 0)
-        When importing
-        And sending query "12345"
-        Then results contain
-         | ID | osm_type | osm_id
-         | 0  | R        | 1
-        When updating place areas
-          | osm_type | osm_id | class    | type        | geometry
-          | R        | 1      | boundary | postal_code | (0 0, 1 0, 1 1, 0 1, 0 0)
-        Then table placex has no entry for R1
-

diff --git a/tests/features/db/update/search_terms.feature b/tests/features/db/update/search_terms.feature
deleted file mode 100644 (file)
index d8c4440..0000000
--- a/tests/features/db/update/search_terms.feature
+++ /dev/null
@@ -1,117 +0,0 @@
-@DB
-Feature: Update of search terms
-    Tests that search_name table is filled correctly
-
-    Scenario: POI-inherited postcode remains when way type is changed
-        Given the scene roads-with-pois
-        And the place nodes
-         | osm_id | class | type  | housenumber | postcode | street   | geometry
-         | 1      | place | house | 1           | 12345    | North St |:p-S1
-        And the place ways
-         | osm_id | class   | type        | name     | geometry
-         | 1      | highway | residential | North St | :w-north
-        When importing
-        Then search_name table contains
-         | place_id | nameaddress_vector
-         | W1       | 12345
-        When updating place ways
-         | osm_id | class   | type         | name     | geometry
-         | 1      | highway | unclassified | North St | :w-north
-        Then search_name table contains
-         | place_id | nameaddress_vector
-         | W1       | 12345
-
-    Scenario: POI-inherited postcode remains when way name is changed
-        Given the scene roads-with-pois
-        And the place nodes
-         | osm_id | class | type  | housenumber | postcode | street   | geometry
-         | 1      | place | house | 1           | 12345    | North St |:p-S1
-        And the place ways
-         | osm_id | class   | type        | name     | geometry
-         | 1      | highway | residential | North St | :w-north
-        When importing
-        Then search_name table contains
-         | place_id | nameaddress_vector
-         | W1       | 12345
-        When updating place ways
-         | osm_id | class   | type         | name     | geometry
-         | 1      | highway | unclassified | South St | :w-north
-        Then search_name table contains
-         | place_id | nameaddress_vector
-         | W1       | 12345
-
-    Scenario: POI-inherited postcode remains when way geometry is changed
-        Given the scene roads-with-pois
-        And the place nodes
-         | osm_id | class | type  | housenumber | postcode | street   | geometry
-         | 1      | place | house | 1           | 12345    | North St |:p-S1
-        And the place ways
-         | osm_id | class   | type        | name     | geometry
-         | 1      | highway | residential | North St | :w-north
-        When importing
-        Then search_name table contains
-         | place_id | nameaddress_vector
-         | W1       | 12345
-        When updating place ways
-         | osm_id | class   | type         | name     | geometry
-         | 1      | highway | unclassified | South St | :w-south
-        Then search_name table contains
-         | place_id | nameaddress_vector
-         | W1       | 12345
-
-    Scenario: POI-inherited postcode is added when POI postcode changes
-        Given the scene roads-with-pois
-        And the place nodes
-         | osm_id | class | type  | housenumber | postcode | street   | geometry
-         | 1      | place | house | 1           | 12345    | North St |:p-S1
-        And the place ways
-         | osm_id | class   | type        | name     | geometry
-         | 1      | highway | residential | North St | :w-north
-        When importing
-        Then search_name table contains
-         | place_id | nameaddress_vector
-         | W1       | 12345
-        When updating place nodes
-         | osm_id | class | type  | housenumber | postcode | street   | geometry
-         | 1      | place | house | 1           | 54321    | North St |:p-S1
-        Then search_name table contains
-         | place_id | nameaddress_vector
-         | W1       | 54321
-
-    Scenario: POI-inherited postcode remains when POI geometry changes
-        Given the scene roads-with-pois
-        And the place nodes
-         | osm_id | class | type  | housenumber | postcode | street   | geometry
-         | 1      | place | house | 1           | 12345    | North St |:p-S1
-        And the place ways
-         | osm_id | class   | type        | name     | geometry
-         | 1      | highway | residential | North St | :w-north
-        When importing
-        Then search_name table contains
-         | place_id | nameaddress_vector
-         | W1       | 12345
-        When updating place nodes
-         | osm_id | class | type  | housenumber | postcode | street   | geometry
-         | 1      | place | house | 1           | 12345    | North St |:p-S2
-        Then search_name table contains
-         | place_id | nameaddress_vector
-         | W1       | 12345
-
-
-    Scenario: POI-inherited postcode remains when another POI is deleted
-        Given the scene roads-with-pois
-        And the place nodes
-         | osm_id | class | type  | housenumber | postcode | street   | geometry
-         | 1      | place | house | 1           | 12345    | North St |:p-S1
-         | 2      | place | house | 2           |          | North St |:p-S2
-        And the place ways
-         | osm_id | class   | type        | name     | geometry
-         | 1      | highway | residential | North St | :w-north
-        When importing
-        Then search_name table contains
-         | place_id | nameaddress_vector
-         | W1       | 12345
-        When marking for delete N2
-        Then search_name table contains
-         | place_id | nameaddress_vector
-         | W1       | 12345

diff --git a/tests/features/db/update/simple.feature b/tests/features/db/update/simple.feature
deleted file mode 100644 (file)
index 517e7bd..0000000
--- a/tests/features/db/update/simple.feature
+++ /dev/null
@@ -1,73 +0,0 @@
-@DB
-Feature: Update of simple objects
-    Testing simple stuff
-
-    Scenario: Do delete small boundary features
-        Given the place areas
-          | osm_type | osm_id | class    | type           | admin_level | geometry
-          | R        | 1      | boundary | administrative | 3           | (0 0, 1 0, 1 1, 0 1, 0 0)
-        When importing
-        Then table placex contains
-          | object | rank_search
-          | R1     | 6
-        When marking for delete R1
-        Then table placex has no entry for R1
-
-    Scenario: Do not delete large boundary features
-        Given the place areas
-          | osm_type | osm_id | class    | type           | admin_level | geometry
-          | R        | 1      | boundary | administrative | 3           | (0 0, 2 0, 2 2.1, 0 2, 0 0)
-        When importing
-        Then table placex contains
-          | object | rank_search
-          | R1     | 6
-        When marking for delete R1
-        Then table placex contains 
-          | object | rank_search
-          | R1     | 6
-
-    Scenario: Do delete large features of low rank
-        Given the named place areas
-          | osm_type | osm_id | class    | type          | geometry
-          | W        | 1      | place    | house         | (0 0, 2 0, 2 2.1, 0 2, 0 0)
-          | R        | 1      | boundary | national_park | (0 0, 2 0, 2 2.1, 0 2, 0 0)
-        When importing
-        Then table placex contains
-          | object | rank_address
-          | R1     | 0
-          | W1     | 30
-        When marking for delete R1,W1
-        Then table placex has no entry for W1
-        Then table placex has no entry for R1
-
-
-    Scenario: type mutation
-        Given the place nodes
-          | osm_id | class | type | geometry
-          | 3      | shop  | toys | 1 -1
-        When importing
-        Then table placex contains
-          | object | class | type
-          | N3     | shop  | toys
-        When updating place nodes
-          | osm_id | class | type    | geometry
-          | 3      | shop  | grocery | 1 -1
-        Then table placex contains
-          | object | class | type
-          | N3     | shop  | grocery
-
-
-    Scenario: remove postcode place when house number is added
-        Given the place nodes
-          | osm_id | class | type     | postcode | geometry
-          | 3      | place | postcode | 12345    | 1 -1
-        When importing
-        Then table placex contains
-          | object | class | type
-          | N3     | place | postcode
-        When updating place nodes
-          | osm_id | class | type  | postcode | housenumber | geometry
-          | 3      | place | house | 12345    | 13          | 1 -1
-        Then table placex contains
-          | object | class | type
-          | N3     | place | house

diff --git a/tests/features/osm2pgsql/import/broken.feature b/tests/features/osm2pgsql/import/broken.feature
deleted file mode 100644 (file)
index 58a45f9..0000000
--- a/tests/features/osm2pgsql/import/broken.feature
+++ /dev/null
@@ -1,37 +0,0 @@
-@DB
-Feature: Import of objects with broken geometries by osm2pgsql
-
-    @Fail
-    Scenario: Import way with double nodes
-        Given the osm nodes:
-          | id  | geometry
-          | 100 | 0 0
-          | 101 | 0 0.1
-          | 102 | 0.1 0.2
-        And the osm ways:
-          | id | tags                  | nodes
-          | 1  | 'highway' : 'primary' | 100 101 101 102
-        When loading osm data
-        Then table place contains
-          | object | class   | type    | geometry
-          | W1     | highway | primary | (0 0, 0 0.1, 0.1 0.2)
-
-    Scenario: Import of ballon areas
-        Given the osm nodes:
-          | id  | geometry
-          | 1   | 0 0
-          | 2   | 0 0.0001
-          | 3   | 0.00001 0.0001
-          | 4   | 0.00001 0
-          | 5   | -0.00001 0
-        And the osm ways:
-          | id | tags                       | nodes
-          | 1  | 'highway' : 'unclassified' | 1 2 3 4 1 5
-          | 2  | 'highway' : 'unclassified' | 1 2 3 4 1
-          | 3  | 'highway' : 'unclassified' | 1 2 3 4 3
-        When loading osm data
-        Then table place contains
-          | object | geometrytype
-          | W1     | ST_LineString
-          | W2     | ST_Polygon
-          | W3     | ST_LineString

diff --git a/tests/features/osm2pgsql/import/relation.feature b/tests/features/osm2pgsql/import/relation.feature
deleted file mode 100644 (file)
index aba99a4..0000000
--- a/tests/features/osm2pgsql/import/relation.feature
+++ /dev/null
@@ -1,13 +0,0 @@
-@DB
-Feature: Import of relations by osm2pgsql
-    Testing specific relation problems related to members.
-
-    Scenario: Don't import empty waterways
-        Given the osm nodes:
-          | id | tags
-          | 1  | 'amenity' : 'prison', 'name' : 'foo'
-        And the osm relations:
-          | id | tags                                                     | members
-          | 1  | 'type' : 'waterway', 'waterway' : 'river', 'name' : 'XZ' | N1
-        When loading osm data
-        Then table place has no entry for R1

diff --git a/tests/features/osm2pgsql/import/simple.feature b/tests/features/osm2pgsql/import/simple.feature
deleted file mode 100644 (file)
index 447dab0..0000000
--- a/tests/features/osm2pgsql/import/simple.feature
+++ /dev/null
@@ -1,68 +0,0 @@
-@DB
-Feature: Import of simple objects by osm2pgsql
-    Testing basic tagging in osm2pgsql imports.
-
-    Scenario: Import simple objects
-        Given the osm nodes:
-          | id | tags
-          | 1  | 'amenity' : 'prison', 'name' : 'foo'
-        Given the osm nodes:
-          | id  | geometry
-          | 100 | 0 0
-          | 101 | 0 0.1
-          | 102 | 0.1 0.2
-          | 200 | 0 0
-          | 201 | 0 1
-          | 202 | 1 1
-          | 203 | 1 0
-        And the osm ways:
-          | id | tags                             | nodes
-          | 1  | 'shop' : 'toys', 'name' : 'tata' | 100 101 102
-          | 2  | 'ref' : '45'                     | 200 201 202 203 200
-        And the osm relations:
-          | id | tags                                                        | members
-          | 1  | 'type' : 'multipolygon', 'tourism' : 'hotel', 'name' : 'XZ' | N1,W2
-        When loading osm data
-        Then table place contains
-          | object | class   | type   | name
-          | N1     | amenity | prison | 'name' : 'foo'
-          | W1     | shop    | toys   | 'name' : 'tata'
-          | R1     | tourism | hotel  | 'name' : 'XZ'
-
-     Scenario: Import object with two main tags
-        Given the osm nodes:
-          | id | tags
-          | 1  | 'tourism' : 'hotel', 'amenity' : 'restaurant', 'name' : 'foo'
-        When loading osm data
-        Then table place contains
-          | object     | class   | type       | name
-          | N1:tourism | tourism | hotel      | 'name' : 'foo'
-          | N1:amenity | amenity | restaurant | 'name' : 'foo'
-
-     Scenario: Import stand-alone house number with postcode
-        Given the osm nodes:
-          | id | tags
-          | 1  | 'addr:housenumber' : '4', 'addr:postcode' : '3345'
-        When loading osm data
-        Then table place contains
-          | object | class | type
-          | N1     | place | house
-
-     Scenario: Landuses are only imported when named
-        Given the osm nodes:
-          | id  | geometry
-          | 100 | 0 0
-          | 101 | 0 0.1
-          | 102 | 0.1 0.1
-          | 200 | 0 0
-          | 202 | 1 1
-          | 203 | 1 0
-        And the osm ways:
-          | id | tags                                          | nodes
-          | 1  | 'landuse' : 'residential', 'name' : 'rainbow' | 100 101 102 100
-          | 2  | 'landuse' : 'residential'                     | 200 202 203 200
-        When loading osm data
-        Then table place contains
-          | object | class   | type
-          | W1     | landuse | residential
-        And table place has no entry for W2

diff --git a/tests/features/osm2pgsql/import/tags.feature b/tests/features/osm2pgsql/import/tags.feature
deleted file mode 100644 (file)
index 3e3d853..0000000
--- a/tests/features/osm2pgsql/import/tags.feature
+++ /dev/null
@@ -1,550 +0,0 @@
-@DB
-Feature: Tag evaluation
-    Tests if tags are correctly imported into the place table
-
-    Scenario Outline: Name tags
-        Given the osm nodes:
-         | id | tags
-         | 1  | 'highway' : 'yes', '<nametag>' : 'Foo'
-        When loading osm data
-        Then table place contains
-         | object | name
-         | N1     | '<nametag>' : 'Foo'
-
-    Examples:
-     | nametag
-     | ref
-     | int_ref
-     | nat_ref
-     | reg_ref
-     | loc_ref
-     | old_ref
-     | iata
-     | icao
-     | pcode:1
-     | pcode:2
-     | pcode:3
-     | name
-     | name:de
-     | name:bt-BR
-     | int_name
-     | int_name:xxx
-     | nat_name
-     | nat_name:fr
-     | reg_name
-     | reg_name:1
-     | loc_name
-     | loc_name:DE
-     | old_name
-     | old_name:v1
-     | alt_name
-     | alt_name:dfe
-     | alt_name_1
-     | official_name
-     | short_name
-     | short_name:CH
-     | addr:housename
-     | brand
-
-    Scenario Outline: operator only for shops and amenities
-        Given the osm nodes:
-         | id | tags
-         | 1  | 'highway' : 'yes', 'operator' : 'Foo', 'name' : 'null'
-         | 2  | 'shop' : 'grocery', 'operator' : 'Foo'
-         | 3  | 'amenity' : 'hospital', 'operator' : 'Foo'
-         | 4  | 'tourism' : 'hotel', 'operator' : 'Foo'
-        When loading osm data
-        Then table place contains
-         | object | name
-         | N1     | 'name' : 'null'
-         | N2     | 'operator' : 'Foo'
-         | N3     | 'operator' : 'Foo'
-         | N4     | 'operator' : 'Foo'
-
-    Scenario Outline: Ignored name tags
-        Given the osm nodes:
-         | id | tags
-         | 1  | 'highway' : 'yes', '<nametag>' : 'Foo', 'name' : 'real'
-        When loading osm data
-        Then table place contains
-         | object | name
-         | N1     | 'name' : 'real'
-
-    Examples:
-     | nametag
-     | name_de
-     | Name
-     | ref:de
-     | ref_de
-     | my:ref
-     | br:name
-     | name:prefix
-     | name:source
-
-    Scenario: Special character in name tag
-        Given the osm nodes:
-         | id | tags
-         | 1  | 'highway' : 'yes', 'name: de' : 'Foo', 'name' : 'real1'
-         | 2  | 'highway' : 'yes', 'name:&#xa;de' : 'Foo', 'name' : 'real2'
-         | 3  | 'highway' : 'yes', 'name:&#x9;de' : 'Foo', 'name:\\' : 'real3'
-        When loading osm data
-        Then table place contains
-         | object | name
-         | N1     | 'name: de' : 'Foo', 'name' : 'real1'
-         | N2     | 'name: de' : 'Foo', 'name' : 'real2'
-         | N3     | 'name: de' : 'Foo', 'name:\\' : 'real3'
-
-    Scenario Outline: Included places
-        Given the osm nodes:
-         | id | tags
-         | 1  | '<key>' : '<value>', 'name' : 'real'
-        When loading osm data
-        Then table place contains
-         | object | name
-         | N1     | 'name' : 'real'
-
-    Examples:
-     | key       | value
-     | emergency | phone
-     | tourism   | information
-     | historic  | castle
-     | military  | barracks
-     | natural   | water
-     | highway   | residential
-     | aerialway | station
-     | aeroway   | way
-     | boundary  | administrative
-     | craft     | butcher
-     | leisure   | playground
-     | office    | bookmaker
-     | railway   | rail
-     | shop      | bookshop
-     | waterway  | stream
-     | landuse   | cemetry
-     | man_made  | tower
-     | mountain_pass | yes
-
-    Scenario Outline: Bridges and Tunnels take special name tags
-        Given the osm nodes:
-          | id | tags
-          | 1  | 'highway' : 'road', '<key>' : 'yes', 'name' : 'Rd', '<key>:name' : 'My'
-          | 2  | 'highway' : 'road', '<key>' : 'yes', 'name' : 'Rd'
-        When loading osm data
-        Then table place contains
-          | object     | class   | type | name
-          | N1:highway | highway | road | 'name' : 'Rd'
-          | N1:<key>   | <key>   | yes  | 'name' : 'My'
-          | N2:highway | highway | road | 'name' : 'Rd'
-        And table place has no entry for N2:<key>
-
-    Examples:
-      | key
-      | bridge
-      | tunnel
-
-    Scenario Outline: Excluded places
-        Given the osm nodes:
-         | id | tags
-         | 1  | '<key>' : '<value>', 'name' : 'real'
-         | 2  | 'highway' : 'motorway', 'name' : 'To Hell'
-        When loading osm data
-        Then table place has no entry for N1
-
-    Examples:
-     | key       | value
-     | emergency | yes
-     | emergency | no
-     | tourism   | yes
-     | tourism   | no
-     | historic  | yes
-     | historic  | no
-     | military  | yes
-     | military  | no
-     | natural   | yes
-     | natural   | no
-     | highway   | no
-     | highway   | turning_circle
-     | highway   | mini_roundabout
-     | highway   | noexit
-     | highway   | crossing
-     | aerialway | no
-     | aerialway | pylon
-     | man_made  | survey_point
-     | man_made  | cutline
-     | aeroway   | no
-     | amenity   | no
-     | bridge    | no
-     | craft     | no
-     | leisure   | no
-     | office    | no
-     | railway   | no
-     | railway   | level_crossing
-     | shop      | no
-     | tunnel    | no
-     | waterway  | riverbank
-
-    Scenario: Some tags only are included when named
-        Given the osm nodes:
-         | id | tags
-         | 1  | '<key>' : '<value>'
-         | 2  | '<key>' : '<value>', 'name' : 'To Hell'
-         | 3  | '<key>' : '<value>', 'ref' : '123'
-        When loading osm data
-        Then table place has no entry for N1
-        And table place has no entry for N3
-        And table place contains
-         | object | class | type
-         | N2     | <key> | <value>
-
-    Examples:
-      | key      | value
-      | landuse  | residential
-      | natural  | meadow
-      | highway  | traffic_signals
-      | highway  | service
-      | highway  | cycleway
-      | highway  | path
-      | highway  | footway
-      | highway  | steps
-      | highway  | bridleway
-      | highway  | track
-      | highway  | byway
-      | highway  | motorway_link
-      | highway  | primary_link
-      | highway  | trunk_link
-      | highway  | secondary_link
-      | highway  | tertiary_link
-      | railway  | rail
-      | boundary | administrative
-      | waterway | stream
-
-    Scenario: Footways are not included if they are sidewalks
-        Given the osm nodes:
-         | id | tags
-         | 2  | 'highway' : 'footway', 'name' : 'To Hell', 'footway' : 'sidewalk'
-         | 23 | 'highway' : 'footway', 'name' : 'x'
-        When loading osm data
-        Then table place has no entry for N2
-
-    Scenario: named junctions are included if there is no other tag
-        Given the osm nodes:
-         | id | tags
-         | 1  | 'junction' : 'yes'
-         | 2  | 'highway' : 'secondary', 'junction' : 'roundabout', 'name' : 'To Hell'
-         | 3  | 'junction' : 'yes', 'name' : 'Le Croix'
-        When loading osm data
-        Then table place has no entry for N1
-        And table place has no entry for N2:junction
-        And table place contains
-         | object | class    | type
-         | N3     | junction | yes
-
-    Scenario: Boundary with place tag
-        Given the osm nodes:
-          | id  | geometry
-          | 200 | 0 0
-          | 201 | 0 1
-          | 202 | 1 1
-          | 203 | 1 0
-        And the osm ways:
-          | id | tags                                                              | nodes
-          | 2  | 'boundary' : 'administrative', 'place' : 'city', 'name' : 'Foo'   | 200 201 202 203 200
-          | 4  | 'boundary' : 'administrative', 'place' : 'island','name' : 'Foo'  | 200 201 202 203 200
-          | 20 | 'place' : 'city', 'name' : 'ngng'                                 | 200 201 202 203 200
-          | 40 | 'place' : 'city', 'boundary' : 'statistical', 'name' : 'BB'       | 200 201 202 203 200
-        When loading osm data
-        Then table place contains
-          | object       | class    | extratags        | type
-          | W2           | boundary | 'place' : 'city' | administrative
-          | W4:boundary  | boundary | None             | administrative
-          | W4:place     | place    | None             | island
-          | W20          | place    | None             | city
-          | W40:boundary | boundary | None             | statistical
-          | W40:place    | place    | None             | city
-        And table place has no entry for W2:place
-
-    Scenario Outline: Tags that describe a house
-        Given the osm nodes:
-          | id  | tags
-          | 100 | '<key>' : '<value>'
-          | 999 | 'amenity' : 'prison', '<key>' : '<value>'
-        When loading osm data
-        Then table place contains
-          | object | class   | type
-          | N100   | place   | house
-          | N999   | amenity | prison
-        And table place has no entry for N100:<key>
-        And table place has no entry for N999:<key>
-        And table place has no entry for N999:place
-
-    Examples:
-      | key                     | value
-      | addr:housename          | My Mansion
-      | addr:housenumber        | 456
-      | addr:conscriptionnumber | 4
-      | addr:streetnumber       | 4568765
-
-    Scenario: Only named with no other interesting tag
-        Given the osm nodes:
-          | id  | tags
-          | 1   | 'landuse' : 'meadow'
-          | 2   | 'landuse' : 'residential', 'name' : 'important'
-          | 3   | 'landuse' : 'residential', 'name' : 'important', 'place' : 'hamlet'
-        When loading osm data
-        Then table place contains
-          | object | class   | type
-          | N2     | landuse | residential
-          | N3     | place   | hamlet
-        And table place has no entry for N1
-        And table place has no entry for N3:landuse
-
-    Scenario Outline: Import of postal codes
-        Given the osm nodes:
-          | id  | tags
-          | 10  | 'highway' : 'secondary', '<key>' : '<value>'
-          | 11  | '<key>' : '<value>'
-        When loading osm data
-        Then table place contains
-          | object | class   | type      | postcode
-          | N10    | highway | secondary | <value>
-          | N11    | place   | postcode  | <value>
-        And table place has no entry for N10:place
-
-    Examples:
-      | key              | value
-      | postal_code      | 45736
-      | postcode         | xxx
-      | addr:postcode    | 564
-      | tiger:zip_left   | 00011
-      | tiger:zip_right  | 09123
-
-    Scenario: Import of street and place
-        Given the osm nodes:
-          | id  | tags
-          | 10  | 'amenity' : 'hospital', 'addr:street' : 'Foo St'
-          | 20  | 'amenity' : 'hospital', 'addr:place' : 'Foo Town'
-        When loading osm data
-        Then table place contains
-          | object | class   | type     | street  | addr_place
-          | N10    | amenity | hospital | Foo St  | None
-          | N20    | amenity | hospital | None    | Foo Town
-
-
-    Scenario Outline: Import of country
-        Given the osm nodes:
-          | id  | tags
-          | 10  | 'place' : 'village', '<key>' : '<value>'
-        When loading osm data
-        Then table place contains
-          | object | class   | type    | country_code
-          | N10    | place   | village | <value>
-
-    Examples:
-        | key                            | value
-        | country_code                   | us
-        | ISO3166-1                      | XX
-        | is_in:country_code             | __
-        | addr:country                   | ..
-        | addr:country_code              | cv
-
-    Scenario Outline: Ignore country codes with wrong length
-        Given the osm nodes:
-          | id  | tags
-          | 10  | 'place' : 'village', 'country_code' : '<value>'
-        When loading osm data
-        Then table place contains
-          | object | class   | type    | country_code
-          | N10    | place   | village | None
-
-    Examples:
-        | value
-        | X
-        | x
-        | ger
-        | dkeufr
-        | d e
-
-    Scenario: Import of house numbers
-        Given the osm nodes:
-          | id  | tags
-          | 10  | 'building' : 'yes', 'addr:housenumber' : '4b'
-          | 11  | 'building' : 'yes', 'addr:conscriptionnumber' : '003'
-          | 12  | 'building' : 'yes', 'addr:streetnumber' : '2345'
-          | 13  | 'building' : 'yes', 'addr:conscriptionnumber' : '3', 'addr:streetnumber' : '111'
-        When loading osm data
-        Then table place contains
-          | object | class | type   | housenumber
-          | N10    | building | yes  | 4b
-          | N11    | building | yes  | 003
-          | N12    | building | yes  | 2345
-          | N13    | building | yes  | 3/111
-
-    Scenario: Import of address interpolations
-        Given the osm nodes:
-          | id  | tags
-          | 10  | 'addr:interpolation' : 'odd'
-          | 11  | 'addr:housenumber' : '10', 'addr:interpolation' : 'odd'
-          | 12  | 'addr:interpolation' : 'odd', 'addr:housenumber' : '23'
-        When loading osm data
-        Then table place contains
-          | object | class   | type    | housenumber
-          | N10    | place   | houses  | odd
-          | N11    | place   | houses  | odd
-          | N12    | place   | houses  | odd
-
-    Scenario: Shorten tiger:county tags
-        Given the osm nodes:
-          | id  | tags
-          | 10  | 'place' : 'village', 'tiger:county' : 'Feebourgh, AL'
-          | 11  | 'place' : 'village', 'addr:state' : 'Alabama', 'tiger:county' : 'Feebourgh, AL'
-          | 12  | 'place' : 'village', 'tiger:county' : 'Feebourgh'
-        When loading osm data
-        Then table place contains
-          | object | class   | type    | isin
-          | N10    | place   | village | Feebourgh county
-          | N11    | place   | village | Feebourgh county,Alabama
-          | N12    | place   | village | Feebourgh county
-
-    Scenario Outline: Import of address tags
-        Given the osm nodes:
-          | id  | tags
-          | 10  | 'place' : 'village', '<key>' : '<value>'
-        When loading osm data
-        Then table place contains
-          | object | class   | type    | isin
-          | N10    | place   | village | <value>
-
-    Examples:
-      | key             | value
-      | is_in           | Stockholm, Sweden
-      | is_in:country   | Xanadu
-      | addr:suburb     | hinein
-      | addr:county     | le havre
-      | addr:city       | Sydney
-      | addr:state      | Jura
-
-    Scenario: Import of admin level
-        Given the osm nodes:
-          | id  | tags
-          | 10  | 'amenity' : 'hospital', 'admin_level' : '3'
-          | 11  | 'amenity' : 'hospital', 'admin_level' : 'b'
-          | 12  | 'amenity' : 'hospital'
-          | 13  | 'amenity' : 'hospital', 'admin_level' : '3.0'
-        When loading osm data
-        Then table place contains
-          | object | class   | type     | admin_level
-          | N10    | amenity | hospital | 3
-          | N11    | amenity | hospital | 100
-          | N12    | amenity | hospital | 100
-          | N13    | amenity | hospital | 3
-
-    Scenario: Import of extra tags
-        Given the osm nodes:
-          | id  | tags
-          | 10  | 'tourism' : 'hotel', '<key>' : 'foo'
-        When loading osm data
-        Then table place contains
-          | object | class   | type  | extratags
-          | N10    | tourism | hotel | '<key>' : 'foo'
-
-     Examples:
-       | key
-       | tracktype
-       | traffic_calming
-       | service
-       | cuisine
-       | capital
-       | dispensing
-       | religion
-       | denomination
-       | sport
-       | internet_access
-       | lanes
-       | surface
-       | smoothness
-       | width
-       | est_width
-       | incline
-       | opening_hours
-       | collection_times
-       | service_times
-       | disused
-       | wheelchair
-       | sac_scale
-       | trail_visibility
-       | mtb:scale
-       | mtb:description
-       | wood
-       | drive_in
-       | access
-       | vehicle
-       | bicyle
-       | foot
-       | goods
-       | hgv
-       | motor_vehicle
-       | motor_car
-       | access:foot
-       | contact:phone
-       | drink:mate
-       | oneway
-       | date_on
-       | date_off
-       | day_on
-       | day_off
-       | hour_on
-       | hour_off
-       | maxweight
-       | maxheight
-       | maxspeed
-       | disused
-       | toll
-       | charge
-       | population
-       | description
-       | image
-       | attribution
-       | fax
-       | email
-       | url
-       | website
-       | phone
-       | real_ale
-       | smoking
-       | food
-       | camera
-       | brewery
-       | locality
-       | wikipedia
-       | wikipedia:de
-       | wikidata
-       | name:prefix
-       | name:botanical
-       | name:etymology:wikidata
-
-    Scenario: buildings
-        Given the osm nodes:
-          | id  | tags
-          | 10  | 'tourism' : 'hotel', 'building' : 'yes'
-          | 11  | 'building' : 'house'
-          | 12  | 'building' : 'shed', 'addr:housenumber' : '1'
-          | 13  | 'building' : 'yes', 'name' : 'Das Haus'
-          | 14  | 'building' : 'yes', 'addr:postcode' : '12345'
-        When loading osm data
-        Then table place contains
-          | object | class   | type
-          | N10    | tourism | hotel
-          | N12    | building| yes
-          | N13    | building| yes
-          | N14    | building| yes
-        And table place has no entry for N10:building
-        And table place has no entry for N11
-
-   Scenario: complete node entry
-       Given the osm nodes:
-         | id        | tags
-         | 290393920 | 'addr:city':'Perpignan','addr:country':'FR','addr:housenumber':'43\\','addr:postcode':'66000','addr:street':'Rue Pierre Constant d`Ivry','source':'cadastre-dgi-fr source : Direction Générale des Impôts - Cadastre ; mise à jour :2008'
-        When loading osm data
-        Then table place contains
-         | object     | class   | type | housenumber
-         | N290393920 | place   | house| 43\

diff --git a/tests/features/osm2pgsql/update/relation.feature b/tests/features/osm2pgsql/update/relation.feature
deleted file mode 100644 (file)
index f7bf53a..0000000
--- a/tests/features/osm2pgsql/update/relation.feature
+++ /dev/null
@@ -1,152 +0,0 @@
-@DB
-Feature: Update of relations by osm2pgsql
-    Testing relation update by osm2pgsql.
-
-Scenario: Remove all members of a relation
-        Given the osm nodes:
-          | id | tags
-          | 1  | 'amenity' : 'prison', 'name' : 'foo'
-        Given the osm nodes:
-          | id  | geometry
-          | 200 | 0 0
-          | 201 | 0 0.0001
-          | 202 | 0.0001 0.0001
-          | 203 | 0.0001 0
-        Given the osm ways:
-          | id | tags                             | nodes
-          | 2  | 'ref' : '45'                     | 200 201 202 203 200
-        Given the osm relations:
-          | id | tags                                                        | members
-          | 1  | 'type' : 'multipolygon', 'tourism' : 'hotel', 'name' : 'XZ' | W2
-        When loading osm data
-        Then table place contains
-          | object | class   | type   | name
-          | R1     | tourism | hotel  | 'name' : 'XZ'
-        Given the osm relations:
-          | action | id | tags                                                        | members
-          | M      | 1  | 'type' : 'multipolygon', 'tourism' : 'hotel', 'name' : 'XZ' | N1
-          When updating osm data
-        Then table place has no entry for R1
-
-
-Scenario: Change type of a relation
-        Given the osm nodes:
-          | id  | geometry
-          | 200 | 0 0
-          | 201 | 0 0.0001
-          | 202 | 0.0001 0.0001
-          | 203 | 0.0001 0
-        Given the osm ways:
-          | id | tags                             | nodes
-          | 2  | 'ref' : '45'                     | 200 201 202 203 200
-        Given the osm relations:
-          | id | tags                                                        | members
-          | 1  | 'type' : 'multipolygon', 'tourism' : 'hotel', 'name' : 'XZ' | W2
-        When loading osm data
-        Then table place contains
-          | object | class   | type   | name
-          | R1     | tourism | hotel  | 'name' : 'XZ'
-        Given the osm relations:
-          | action | id | tags                                                        | members
-          | M      | 1  | 'type' : 'multipolygon', 'amenity' : 'prison', 'name' : 'XZ' | W2
-          When updating osm data
-        Then table place has no entry for R1:tourism
-        And table place contains
-          | object | class   | type   | name
-          | R1     | amenity | prison | 'name' : 'XZ'
-
-Scenario: Change name of a relation
-        Given the osm nodes:
-          | id  | geometry
-          | 200 | 0 0
-          | 201 | 0 0.0001
-          | 202 | 0.0001 0.0001
-          | 203 | 0.0001 0
-        Given the osm ways:
-          | id | tags                             | nodes
-          | 2  | 'ref' : '45'                     | 200 201 202 203 200
-        Given the osm relations:
-          | id | tags                                                        | members
-          | 1  | 'type' : 'multipolygon', 'tourism' : 'hotel', 'name' : 'AB' | W2
-        When loading osm data
-        Then table place contains
-          | object | class   | type   | name
-          | R1     | tourism | hotel  | 'name' : 'AB'
-        Given the osm relations:
-          | action | id | tags                                                        | members
-          | M      | 1  | 'type' : 'multipolygon', 'tourism' : 'hotel', 'name' : 'XZ' | W2
-        When updating osm data
-        Then table place contains
-          | object | class   | type   | name
-          | R1     | tourism | hotel  | 'name' : 'XZ'
-
-
-Scenario: Change type of a relation into something unknown
-        Given the osm nodes:
-          | id  | geometry
-          | 200 | 0 0
-          | 201 | 0 0.0001
-          | 202 | 0.0001 0.0001
-          | 203 | 0.0001 0
-        Given the osm ways:
-          | id | tags                             | nodes
-          | 2  | 'ref' : '45'                     | 200 201 202 203 200
-        Given the osm relations:
-          | id | tags                                                        | members
-          | 1  | 'type' : 'multipolygon', 'tourism' : 'hotel', 'name' : 'XZ' | W2
-        When loading osm data
-        Then table place contains
-          | object | class   | type   | name
-          | R1     | tourism | hotel  | 'name' : 'XZ'
-        Given the osm relations:
-          | action | id | tags                                                        | members
-          | M      | 1  | 'type' : 'multipolygon', 'amenities' : 'prison', 'name' : 'XZ' | W2
-          When updating osm data
-        Then table place has no entry for R1
-
-Scenario: Type tag is removed
-        Given the osm nodes:
-          | id  | geometry
-          | 200 | 0 0
-          | 201 | 0 0.0001
-          | 202 | 0.0001 0.0001
-          | 203 | 0.0001 0
-        Given the osm ways:
-          | id | tags                             | nodes
-          | 2  | 'ref' : '45'                     | 200 201 202 203 200
-        Given the osm relations:
-          | id | tags                                                        | members
-          | 1  | 'type' : 'multipolygon', 'tourism' : 'hotel', 'name' : 'XZ' | W2
-        When loading osm data
-        Then table place contains
-          | object | class   | type   | name
-          | R1     | tourism | hotel  | 'name' : 'XZ'
-        Given the osm relations:
-          | action | id | tags                               | members
-          | M      | 1  | 'tourism' : 'hotel', 'name' : 'XZ' | W2
-          When updating osm data
-        Then table place has no entry for R1
-
-Scenario: Type tag is renamed to something unknown
-        Given the osm nodes:
-          | id  | geometry
-          | 200 | 0 0
-          | 201 | 0 0.0001
-          | 202 | 0.0001 0.0001
-          | 203 | 0.0001 0
-        Given the osm ways:
-          | id | tags                             | nodes
-          | 2  | 'ref' : '45'                     | 200 201 202 203 200
-        Given the osm relations:
-          | id | tags                                                        | members
-          | 1  | 'type' : 'multipolygon', 'tourism' : 'hotel', 'name' : 'XZ' | W2
-        When loading osm data
-        Then table place contains
-          | object | class   | type   | name
-          | R1     | tourism | hotel  | 'name' : 'XZ'
-        Given the osm relations:
-          | action | id | tags                               | members
-          | M      | 1  | 'type' : 'multipolygonn', 'tourism' : 'hotel', 'name' : 'XZ' | W2
-          When updating osm data
-        Then table place has no entry for R1
-

diff --git a/tests/features/osm2pgsql/update/simple.feature b/tests/features/osm2pgsql/update/simple.feature
deleted file mode 100644 (file)
index e0c9b00..0000000
--- a/tests/features/osm2pgsql/update/simple.feature
+++ /dev/null
@@ -1,22 +0,0 @@
-@DB
-Feature: Update of simple objects by osm2pgsql
-    Testing basic update functions of osm2pgsql.
-
-    Scenario: Import object with two main tags
-        Given the osm nodes:
-          | id | tags
-          | 1  | 'tourism' : 'hotel', 'amenity' : 'restaurant', 'name' : 'foo'
-        When loading osm data
-        Then table place contains
-          | object     | class   | type       | name
-          | N1:tourism | tourism | hotel      | 'name' : 'foo'
-          | N1:amenity | amenity | restaurant | 'name' : 'foo'
-        Given the osm nodes:
-          | action | id | tags
-          | M      | 1  | 'tourism' : 'hotel', 'name' : 'foo'
-        When updating osm data
-        Then table place has no entry for N1:amenity
-        And table place contains
-          | object     | class   | type       | name
-          | N1:tourism | tourism | hotel      | 'name' : 'foo'
-

diff --git a/tests/steps/api_result.py b/tests/steps/api_result.py
deleted file mode 100644 (file)
index 2644d4a..0000000
--- a/tests/steps/api_result.py
+++ /dev/null
@@ -1,286 +0,0 @@
-""" Steps for checking the results of queries.
-"""
-
-from nose.tools import *
-from lettuce import *
-from tidylib import tidy_document
-from collections import OrderedDict
-import json
-import logging
-import re
-from xml.dom.minidom import parseString
-
-logger = logging.getLogger(__name__)
-
-def _parse_xml():
-    """ Puts the DOM structure into more convenient python
-        with a similar structure as the json document, so
-        that the same the semantics can be used. It does not
-        check if the content is valid (or at least not more than
-        necessary to transform it into a dict structure).
-    """
-    page = parseString(world.page).documentElement
-
-    # header info
-    world.result_header = OrderedDict(page.attributes.items())
-    logger.debug('Result header: %r' % (world.result_header))
-    world.results = []
-
-    # results
-    if page.nodeName == 'searchresults' or page.nodeName == 'lookupresults':
-        for node in page.childNodes:
-            if node.nodeName != "#text":
-                assert_equals(node.nodeName, 'place', msg="Unexpected element '%s'" % node.nodeName)
-                newresult = OrderedDict(node.attributes.items())
-                assert_not_in('address', newresult)
-                assert_not_in('geokml', newresult)
-                assert_not_in('extratags', newresult)
-                assert_not_in('namedetails', newresult)
-                address = OrderedDict()
-                for sub in node.childNodes:
-                    if sub.nodeName == 'geokml':
-                        newresult['geokml'] = sub.childNodes[0].toxml()
-                    elif sub.nodeName == 'extratags':
-                        newresult['extratags'] = {}
-                        for tag in sub.childNodes:
-                            assert_equals(tag.nodeName, 'tag')
-                            attrs = dict(tag.attributes.items())
-                            assert_in('key', attrs)
-                            assert_in('value', attrs)
-                            newresult['extratags'][attrs['key']] = attrs['value']
-                    elif sub.nodeName == 'namedetails':
-                        newresult['namedetails'] = {}
-                        for tag in sub.childNodes:
-                            assert_equals(tag.nodeName, 'name')
-                            attrs = dict(tag.attributes.items())
-                            assert_in('desc', attrs)
-                            newresult['namedetails'][attrs['desc']] = tag.firstChild.nodeValue.strip()
-
-                    elif sub.nodeName == '#text':
-                        pass
-                    else:
-                        address[sub.nodeName] = sub.firstChild.nodeValue.strip()
-                if address:
-                    newresult['address'] = address
-                world.results.append(newresult)
-    elif page.nodeName == 'reversegeocode':
-        haserror = False
-        address = {}
-        for node in page.childNodes:
-            if node.nodeName == 'result':
-                assert_equals(len(world.results), 0)
-                assert (not haserror)
-                world.results.append(OrderedDict(node.attributes.items()))
-                assert_not_in('display_name', world.results[0])
-                assert_not_in('address', world.results[0])
-                world.results[0]['display_name'] = node.firstChild.nodeValue.strip()
-            elif node.nodeName == 'error':
-                assert_equals(len(world.results), 0)
-                haserror = True
-            elif node.nodeName == 'addressparts':
-                assert (not haserror)
-                address = OrderedDict()
-                for sub in node.childNodes:
-                    address[sub.nodeName] = sub.firstChild.nodeValue.strip()
-                world.results[0]['address'] = address
-            elif node.nodeName == 'extratags':
-                world.results[0]['extratags'] = {}
-                for tag in node.childNodes:
-                    assert_equals(tag.nodeName, 'tag')
-                    attrs = dict(tag.attributes.items())
-                    assert_in('key', attrs)
-                    assert_in('value', attrs)
-                    world.results[0]['extratags'][attrs['key']] = attrs['value']
-            elif node.nodeName == 'namedetails':
-                world.results[0]['namedetails'] = {}
-                for tag in node.childNodes:
-                    assert_equals(tag.nodeName, 'name')
-                    attrs = dict(tag.attributes.items())
-                    assert_in('desc', attrs)
-                    world.results[0]['namedetails'][attrs['desc']] = tag.firstChild.nodeValue.strip()
-            elif node.nodeName == "geokml":
-                world.results[0]['geokml'] = node
-            elif node.nodeName == "#text":
-                pass
-            else:
-                assert False, "Unknown content '%s' in XML" % node.nodeName
-    else:
-        assert False, "Unknown document node name %s in XML" % page.nodeName
-
-    logger.debug("The following was parsed out of XML:")
-    logger.debug(world.results)
-
-@step(u'a HTTP (\d+) is returned')
-def api_result_http_error(step, error):
-    assert_equals(world.returncode, int(error))
-
-@step(u'the result is valid( \w+)?')
-def api_result_is_valid(step, fmt):
-    assert_equals(world.returncode, 200)
-
-    if world.response_format == 'html':
-        document, errors = tidy_document(world.page, 
-                             options={'char-encoding' : 'utf8'})
-        # assert(len(errors) == 0), "Errors found in HTML document:\n%s" % errors
-        world.results = document
-    elif world.response_format == 'xml':
-        _parse_xml()
-    elif world.response_format == 'json':
-        world.results = json.JSONDecoder(object_pairs_hook=OrderedDict).decode(world.page)
-        if world.request_type == 'reverse':
-            world.results = (world.results,)
-    else:
-        assert False, "Unknown page format: %s" % (world.response_format)
-
-    if fmt:
-        assert_equals (fmt.strip(), world.response_format)
-
-
-def compare(operator, op1, op2):
-    if operator == 'less than':
-        return op1 < op2
-    elif operator == 'more than':
-        return op1 > op2
-    elif operator == 'exactly':
-        return op1 == op2
-    elif operator == 'at least':
-        return op1 >= op2
-    elif operator == 'at most':
-        return op1 <= op2
-    else:
-        raise Exception("unknown operator '%s'" % operator)
-
-@step(u'(less than|more than|exactly|at least|at most) (\d+) results? (?:is|are) returned')
-def validate_result_number(step, operator, number):
-    step.given('the result is valid')
-    numres = len(world.results)
-    assert compare(operator, numres, int(number)), \
-        "Bad number of results: expected %s %s, got %d." % (operator, number, numres)
-
-@step(u'result (\d+) has( not)? attributes (\S+)')
-def search_check_for_result_attribute(step, num, invalid, attrs):
-    num = int(num)
-    step.given('at least %d results are returned' % (num + 1))
-    res = world.results[num]
-    for attr in attrs.split(','):
-        if invalid:
-            assert_not_in(attr.strip(), res)
-        else:
-            assert_in(attr.strip(),res)
-        
-@step(u'there is a json wrapper "([^"]*)"')
-def api_result_check_json_wrapper(step, wrapper):
-    step.given('the result is valid json')
-    assert_equals(world.json_callback, wrapper)
-
-@step(u'result header contains')
-def api_result_header_contains(step):
-    step.given('the result is valid')
-    for line in step.hashes:
-        assert_in(line['attr'], world.result_header)
-        m = re.match("%s$" % (line['value'],), world.result_header[line['attr']])
-
-@step(u'result header has no attribute (.*)')
-def api_result_header_contains_not(step, attr):
-    step.given('the result is valid')
-    assert_not_in(attr, world.result_header)
-
-@step(u'results contain$')
-def api_result_contains(step):
-    step.given('at least 1 result is returned')
-    for line in step.hashes:
-        if 'ID' in line:
-            reslist = (world.results[int(line['ID'])],)
-        else:
-            reslist = world.results
-        for k,v in line.iteritems():
-            if k == 'latlon':
-                for curres in reslist:
-                    world.match_geometry((float(curres['lat']), float(curres['lon'])), v)
-            elif k != 'ID':
-                for curres in reslist:
-                    assert_in(k, curres)
-                    if v[0] in '<>=':
-                        # mathematical operation
-                        evalexp = '%s %s' % (curres[k], v)
-                        res = eval(evalexp)
-                        logger.debug('Evaluating: %s = %s' % (res, evalexp))
-                        assert_true(res, "Evaluation failed: %s" % (evalexp, ))
-                    else:
-                        # regex match
-                        m = re.match("%s$" % (v,), curres[k])
-                        assert_is_not_none(m, msg="field %s does not match: %s$ != %s." % (k, v, curres[k]))
-
-@step(u'results contain valid boundingboxes$')
-def api_result_address_contains(step):
-    step.given('the result is valid')
-    for curres in world.results:
-        bb = curres['boundingbox']
-        if world.response_format == 'json':
-            bb = ','.join(bb)
-        m = re.match('^(-?\d+\.\d+),(-?\d+\.\d+),(-?\d+\.\d+),(-?\d+\.\d+)$', bb)
-        assert_is_not_none(m, msg="invalid boundingbox: %s." % (curres['boundingbox']))
-
-@step(u'result addresses contain$')
-def api_result_address_contains(step):
-    step.given('the result is valid')
-    for line in step.hashes:
-        if 'ID' in line:
-            reslist = (world.results[int(line['ID'])],)
-        else:
-            reslist = world.results
-        for k,v in line.iteritems():
-            if k != 'ID':
-                for res in reslist:
-                    curres = res['address']
-                    assert_in(k, curres)
-                    m = re.match("%s$" % (v,), curres[k])
-                    assert_is_not_none(m, msg="field %s does not match: %s$ != %s." % (k, v, curres[k]))
-
-
-@step(u'address of result (\d+) contains')
-def api_result_address_exact(step, resid):
-    resid = int(resid)
-    step.given('at least %d results are returned' % (resid + 1))
-    addr = world.results[resid]['address']
-    for line in step.hashes:
-        assert_in(line['type'], addr)
-        m = re.match("%s$" % line['value'], addr[line['type']])
-        assert_is_not_none(m, msg="field %s does not match: %s$ != %s." % (
-                                  line['type'], line['value'], addr[line['type']]))
-        #assert_equals(line['value'], addr[line['type']])
-
-@step(u'address of result (\d+) does not contain (.*)')
-def api_result_address_details_missing(step, resid, types):
-    resid = int(resid)
-    step.given('at least %d results are returned' % (resid + 1))
-    addr = world.results[resid]['address']
-    for t in types.split(','):
-        assert_not_in(t.strip(), addr)
-
-
-@step(u'address of result (\d+) is')
-def api_result_address_exact(step, resid):
-    resid = int(resid)
-    step.given('at least %d results are returned' % (resid + 1))
-    result = world.results[resid]
-    linenr = 0
-    assert_equals(len(step.hashes), len(result['address']))
-    for k,v in result['address'].iteritems():
-        assert_equals(step.hashes[linenr]['type'], k)
-        assert_equals(step.hashes[linenr]['value'], v)
-        linenr += 1
-
-
-@step('there are( no)? duplicates')
-def api_result_check_for_duplicates(step, nodups=None):
-    step.given('at least 1 result is returned')
-    resarr = []
-    for res in world.results:
-        resarr.append((res['osm_type'], res['class'],
-                        res['type'], res['display_name']))
-
-    if nodups is None:
-        assert len(resarr) > len(set(resarr))
-    else:
-        assert_equal(len(resarr), len(set(resarr)))

diff --git a/tests/steps/api_setup.py b/tests/steps/api_setup.py
deleted file mode 100644 (file)
index c9a4bac..0000000
--- a/tests/steps/api_setup.py
+++ /dev/null
@@ -1,136 +0,0 @@
-""" Steps for setting up and sending API requests.
-"""
-
-from nose.tools import *
-from lettuce import *
-import urllib
-import urllib2
-import logging
-
-logger = logging.getLogger(__name__)
-
-def api_call(requesttype):
-    world.request_type = requesttype
-    world.json_callback = None
-    data = urllib.urlencode(world.params)
-    url = "%s/%s?%s" % (world.config.base_url, requesttype, data)
-    req = urllib2.Request(url=url, headers=world.header)
-    try:
-        fd = urllib2.urlopen(req)
-        world.page = fd.read()
-        world.returncode = 200
-    except urllib2.HTTPError, ex:
-        world.returncode = ex.code
-        world.page = None
-        return
-
-    pageinfo = fd.info()
-    assert_equal('utf-8', pageinfo.getparam('charset').lower())
-    pagetype = pageinfo.gettype()
-
-    fmt = world.params.get('format')
-    if fmt == 'html':
-        assert_equals('text/html', pagetype)
-        world.response_format = fmt
-    elif fmt == 'xml':
-        assert_equals('text/xml', pagetype)
-        world.response_format = fmt
-    elif fmt in ('json', 'jsonv2'):
-        if 'json_callback' in world.params:
-            world.json_callback = world.params['json_callback'].encode('utf8')
-            assert world.page.startswith(world.json_callback + '(')
-            assert world.page.endswith(')')
-            world.page = world.page[(len(world.json_callback)+1):-1]
-            assert_equals('application/javascript', pagetype)
-        else:
-            assert_equals('application/json', pagetype)
-        world.response_format = 'json'
-    else:
-        if requesttype == 'reverse':
-            assert_equals('text/xml', pagetype)
-            world.response_format = 'xml'
-        else:
-            assert_equals('text/html', pagetype)
-            world.response_format = 'html'
-    logger.debug("Page received (%s):" % world.response_format)
-    logger.debug(world.page)
-
-    api_setup_prepare_params(None)
-
-@before.each_scenario
-def api_setup_prepare_params(scenario):
-    world.results = []
-    world.params = {}
-    world.header = {}
-
-@step(u'the request parameters$')
-def api_setup_parameters(step):
-    """Define the parameters of the request as a hash.
-       Resets parameter list.
-    """
-    world.params = step.hashes[0]
-
-@step(u'the HTTP header$')
-def api_setup_parameters(step):
-    """Define additional HTTP header parameters as a hash.
-       Resets parameter list.
-    """
-    world.header = step.hashes[0]
-
-
-@step(u'sending( \w+)? search query "([^"]*)"( with address)?')
-def api_setup_search(step, fmt, query, doaddr):
-    world.params['q'] = query.encode('utf8')
-    if doaddr:
-        world.params['addressdetails'] = 1
-    if fmt:
-        world.params['format'] = fmt.strip()
-    api_call('search')
-
-@step(u'sending( \w+)? structured query( with address)?$')
-def api_setup_structured_search(step, fmt, doaddr):
-    world.params.update(step.hashes[0])
-    if doaddr:
-        world.params['addressdetails'] = 1
-    if fmt:
-        world.params['format'] = fmt.strip()
-    api_call('search')
-
-@step(u'looking up (\w+ )?coordinates ([-\d.]+),([-\d.]+)')
-def api_setup_reverse(step, fmt, lat, lon):
-    world.params['lat'] = lat
-    world.params['lon'] = lon
-    if fmt and fmt.strip():
-        world.params['format'] = fmt.strip()
-    api_call('reverse')
-
-@step(u'looking up place ([NRW]?\d+)')
-def api_setup_details_reverse(step, obj):
-    if obj[0] in ('N', 'R', 'W'):
-        # an osm id
-        world.params['osm_type']  = obj[0]
-        world.params['osm_id'] = obj[1:]
-    else:
-        world.params['place_id']  = obj
-    api_call('reverse')
-
-@step(u'looking up details for ([NRW]?\d+)')
-def api_setup_details(step, obj):
-    if obj[0] in ('N', 'R', 'W'):
-        # an osm id
-        world.params['osmtype']  = obj[0]
-        world.params['osmid'] = obj[1:]
-    else:
-        world.params['place_id']  = obj
-    api_call('details')
-
-@step(u'looking up (\w+) places ((?:[a-z]\d+,*)+)')
-def api_setup_lookup(step, fmt, ids):
-    world.params['osm_ids'] = ids
-    if fmt and fmt.strip():
-        world.params['format'] = fmt.strip()
-    api_call('lookup')
-
-@step(u'sending an API call (\w+)')
-def api_general_call(step, call):
-    api_call(call)

diff --git a/tests/steps/db_results.py b/tests/steps/db_results.py
deleted file mode 100644 (file)
index 53374e7..0000000
--- a/tests/steps/db_results.py
+++ /dev/null
@@ -1,201 +0,0 @@
-""" Steps for checking the DB after import and update tests.
-
-    There are two groups of test here. The first group tests
-    the contents of db tables directly, the second checks
-    query results by using the command line query tool.
-"""
-
-from nose.tools import *
-from lettuce import *
-import psycopg2
-import psycopg2.extensions
-import psycopg2.extras
-import os
-import random
-import json
-import re
-import logging
-from collections import OrderedDict
-
-logger = logging.getLogger(__name__)
-
-@step(u'table placex contains as names for (N|R|W)(\d+)')
-def check_placex_names(step, osmtyp, osmid):
-    """ Check for the exact content of the name hstore in placex.
-    """
-    cur = world.conn.cursor(cursor_factory=psycopg2.extras.DictCursor)
-    cur.execute('SELECT name FROM placex where osm_type = %s and osm_id =%s', (osmtyp, int(osmid)))
-    for line in cur:
-        names = dict(line['name'])
-        for name in step.hashes:
-            assert_in(name['k'], names)
-            assert_equals(names[name['k']], name['v'])
-            del names[name['k']]
-        assert_equals(len(names), 0)
-
-
-
-
-@step(u'table ([a-z_]+) contains$')
-def check_placex_content(step, tablename):
-    """ check that the given lines are in the given table
-        Entries are searched by osm_type/osm_id and then all
-        given columns are tested. If there is more than one
-        line for an OSM object, they must match in these columns.
-    """
-    try:
-        cur = world.conn.cursor(cursor_factory=psycopg2.extras.DictCursor)
-        for line in step.hashes:
-            osmtype, osmid, cls = world.split_id(line['object'])
-            q = 'SELECT *'
-            if tablename == 'placex':
-                q = q + ", ST_X(centroid) as clat, ST_Y(centroid) as clon"
-            if tablename == 'location_property_osmline':
-                q = q + ' FROM %s where osm_id = %%s' % (tablename,)
-            else:
-                q = q + ", ST_GeometryType(geometry) as geometrytype"
-                q = q + ' FROM %s where osm_type = %%s and osm_id = %%s' % (tablename,)
-            if cls is None:
-                if tablename == 'location_property_osmline':
-                    params = (osmid,)
-                else:
-                    params = (osmtype, osmid)
-            else:
-                q = q + ' and class = %s'
-                if tablename == 'location_property_osmline':
-                    params = (osmid, cls)
-                else:
-                    params = (osmtype, osmid, cls)
-            cur.execute(q, params)
-            assert(cur.rowcount > 0)
-            for res in cur:
-                for k,v in line.iteritems():
-                    if not k == 'object':
-                        assert_in(k, res)
-                        if type(res[k]) is dict:
-                            val = world.make_hash(v)
-                            assert_equals(res[k], val)
-                        elif k in ('parent_place_id', 'linked_place_id'):
-                            pid = world.get_placeid(v)
-                            assert_equals(pid, res[k], "Results for '%s'/'%s' differ: '%s' != '%s'" % (line['object'], k, pid, res[k]))
-                        elif k == 'centroid':
-                            world.match_geometry((res['clat'], res['clon']), v)
-                        else:
-                            assert_equals(str(res[k]), v, "Results for '%s'/'%s' differ: '%s' != '%s'" % (line['object'], k, str(res[k]), v))
-    finally:
-        cur.close()
-        world.conn.commit()
-
-@step(u'table (placex?) has no entry for (N|R|W)(\d+)(:\w+)?')
-def check_placex_missing(step, tablename, osmtyp, osmid, placeclass):
-    cur = world.conn.cursor()
-    try:
-        q = 'SELECT count(*) FROM %s where osm_type = %%s and osm_id = %%s' % (tablename, )
-        args = [osmtyp, int(osmid)]
-        if placeclass is not None:
-            q = q + ' and class = %s'
-            args.append(placeclass[1:])
-        cur.execute(q, args)
-        numres = cur.fetchone()[0]
-        assert_equals (numres, 0)
-    finally:
-        cur.close()
-        world.conn.commit()
-
-@step(u'table location_property_osmline has no entry for W(\d+)?')
-def check_osmline_missing(step, osmid):
-    cur = world.conn.cursor()
-    try:
-        q = 'SELECT count(*) FROM location_property_osmline where osm_id = %s' % (osmid, )
-        cur.execute(q)
-        numres = cur.fetchone()[0]
-        assert_equals (numres, 0)
-    finally:
-        cur.close()
-        world.conn.commit()
-
-@step(u'search_name table contains$')
-def check_search_name_content(step):
-    cur = world.conn.cursor(cursor_factory=psycopg2.extras.DictCursor)
-    for line in step.hashes:
-        placeid = world.get_placeid(line['place_id'])
-        cur.execute('SELECT * FROM search_name WHERE place_id = %s', (placeid,))
-        assert(cur.rowcount > 0)
-        for res in cur:
-            for k,v in line.iteritems():
-                if k in ('search_rank', 'address_rank'):
-                    assert_equals(int(v), res[k], "Results for '%s'/'%s' differ: '%s' != '%d'" % (line['place_id'], k, v, res[k]))
-                elif k in ('importance'):
-                    assert_equals(float(v), res[k], "Results for '%s'/'%s' differ: '%s' != '%d'" % (line['place_id'], k, v, res[k]))
-                elif k in ('name_vector', 'nameaddress_vector'):
-                    terms = [x.strip().replace('#', ' ') for x in v.split(',')]
-                    cur.execute('SELECT word_id, word_token FROM word, (SELECT unnest(%s) as term) t WHERE word_token = make_standard_name(t.term)', (terms,))
-                    assert cur.rowcount >= len(terms)
-                    for wid in cur:
-                        assert_in(wid['word_id'], res[k], "Missing term for %s/%s: %s" % (line['place_id'], k, wid['word_token']))
-                elif k in ('country_code'):
-                    assert_equals(v, res[k], "Results for '%s'/'%s' differ: '%s' != '%d'" % (line['place_id'], k, v, res[k]))
-                elif k == 'place_id':
-                    pass
-                else:
-                    raise Exception("Cannot handle field %s in search_name table" % (k, ))
-
-@step(u'way (\d+) expands to lines')
-def check_interpolation_lines(step, wayid):
-    """Check that the correct interpolation line has been entered in
-       location_property_osmline for the given source line/nodes.
-       Expected are three columns:
-       startnumber, endnumber and linegeo
-    """
-    lines = []
-    for line in step.hashes:
-        lines.append((line["startnumber"], line["endnumber"], line["geometry"]))
-    cur = world.conn.cursor(cursor_factory=psycopg2.extras.DictCursor)
-    cur.execute("""SELECT startnumber::text, endnumber::text, st_astext(linegeo) as geometry
-                   FROM location_property_osmline WHERE osm_id = %s""",
-                   (int(wayid),))
-    assert_equals(len(lines), cur.rowcount)
-    for r in cur:
-        linegeo = str(str(r["geometry"].split('(')[1]).split(')')[0]).replace(',', ', ')
-        exp = (r["startnumber"], r["endnumber"], linegeo)
-        assert_in(exp, lines)
-        lines.remove(exp)
-
-@step(u'way (\d+) expands exactly to housenumbers ([0-9,]*)')
-def check_interpolated_housenumber_list(step, nodeid, numberlist):
-    """ Checks that the interpolated house numbers corresponds
-        to the given list.
-    """
-    expected = numberlist.split(',');
-    cur = world.conn.cursor()
-    cur.execute("""SELECT housenumber FROM placex
-                   WHERE osm_type = 'W' and osm_id = %s
-                   and class = 'place' and type = 'address'""", (int(nodeid),))
-    for r in cur:
-        assert_in(r[0], expected, "Unexpected house number %s for node %s." % (r[0], nodeid))
-        expected.remove(r[0])
-    assert_equals(0, len(expected), "Missing house numbers for way %s: %s" % (nodeid, expected))
-
-@step(u'way (\d+) expands to no housenumbers')
-def check_no_interpolated_housenumber_list(step, nodeid):
-    """ Checks that the interpolated house numbers corresponds
-        to the given list.
-    """
-    cur = world.conn.cursor()
-    cur.execute("""SELECT housenumber FROM placex
-                   WHERE osm_type = 'W' and osm_id = %s
-                     and class = 'place' and type = 'address'""", (int(nodeid),))
-    res = [r[0] for r in cur]
-    assert_equals(0, len(res), "Unexpected house numbers for way %s: %s" % (nodeid, res))
-
-@step(u'table search_name has no entry for (.*)')
-def check_placex_missing(step, osmid):
-    """ Checks if there is an entry in the search index for the
-        given place object.
-    """
-    cur = world.conn.cursor()
-    placeid = world.get_placeid(osmid)
-    cur.execute('SELECT count(*) FROM search_name WHERE place_id =%s', (placeid,))
-    numres = cur.fetchone()[0]
-    assert_equals (numres, 0)
-

diff --git a/tests/steps/db_setup.py b/tests/steps/db_setup.py
deleted file mode 100644 (file)
index 727e610..0000000
--- a/tests/steps/db_setup.py
+++ /dev/null
@@ -1,278 +0,0 @@
-""" Steps for setting up a test database with imports and updates.
-
-    There are two ways to state geometries for test data: with coordinates
-    and via scenes.
-
-    Coordinates should be given as a wkt without the enclosing type name.
-
-    Scenes are prepared geometries which can be found in the scenes/data/
-    directory. Each scene is saved in a .wkt file with its name, which
-    contains a list of id/wkt pairs. A scene can be set globally
-    for a scene by using the step `the scene <scene name>`. Then each
-    object should be refered to as `:<object id>`. A geometry can also
-    be referred to without loading the scene by explicitly stating the
-    scene: `<scene name>:<object id>`.
-"""
-
-from nose.tools import *
-from lettuce import *
-import psycopg2
-import psycopg2.extensions
-import psycopg2.extras
-import os
-import subprocess
-import random
-import base64
-import sys
-
-psycopg2.extensions.register_type(psycopg2.extensions.UNICODE)
-
-@before.each_scenario
-def setup_test_database(scenario):
-    """ Creates a new test database from the template database
-        that was set up earlier in terrain.py. Will be done only
-        for scenarios whose feature is tagged with 'DB'.
-    """
-    if scenario.feature.tags is not None and 'DB' in scenario.feature.tags:
-        world.db_template_setup()
-        world.write_nominatim_config(world.config.test_db)
-        conn = psycopg2.connect(database=world.config.template_db)
-        conn.set_isolation_level(0)
-        cur = conn.cursor()
-        cur.execute('DROP DATABASE IF EXISTS %s' % (world.config.test_db, ))
-        cur.execute('CREATE DATABASE %s TEMPLATE = %s' % (world.config.test_db, world.config.template_db))
-        conn.close()
-        world.conn = psycopg2.connect(database=world.config.test_db)
-        psycopg2.extras.register_hstore(world.conn, globally=False, unicode=True)
-
-@step('a wiped database')
-def db_setup_wipe_db(step):
-    """Explicit DB scenario setup only needed
-       to work around a bug where scenario outlines don't call
-       before_each_scenario correctly.
-    """
-    if hasattr(world, 'conn'):
-        world.conn.close()
-    conn = psycopg2.connect(database=world.config.template_db)
-    conn.set_isolation_level(0)
-    cur = conn.cursor()
-    cur.execute('DROP DATABASE IF EXISTS %s' % (world.config.test_db, ))
-    cur.execute('CREATE DATABASE %s TEMPLATE = %s' % (world.config.test_db, world.config.template_db))
-    conn.close()
-    world.conn = psycopg2.connect(database=world.config.test_db)
-    psycopg2.extras.register_hstore(world.conn, globally=False, unicode=True)
-
-
-@after.each_scenario
-def tear_down_test_database(scenario):
-    """ Drops any previously created test database.
-    """
-    if hasattr(world, 'conn'):
-        world.conn.close()
-    if scenario.feature.tags is not None and 'DB' in scenario.feature.tags and not world.config.keep_scenario_db:
-        conn = psycopg2.connect(database=world.config.template_db)
-        conn.set_isolation_level(0)
-        cur = conn.cursor()
-        cur.execute('DROP DATABASE %s' % (world.config.test_db,))
-        conn.close()
-
-
-def _format_placex_cols(cols, geomtype, force_name):
-    if 'name' in cols:
-        if cols['name'].startswith("'"):
-            cols['name'] = world.make_hash(cols['name'])
-        else:
-            cols['name'] = { 'name' : cols['name'] }
-    elif force_name:
-        cols['name'] = { 'name' : base64.urlsafe_b64encode(os.urandom(int(random.random()*30))) }
-    if 'extratags' in cols:
-        cols['extratags'] = world.make_hash(cols['extratags'])
-    if 'admin_level' not in cols:
-        cols['admin_level'] = 100
-    if 'geometry' in cols:
-        coords = world.get_scene_geometry(cols['geometry'])
-        if coords is None:
-            coords = "'%s(%s)'::geometry" % (geomtype, cols['geometry'])
-        else:
-            coords = "'%s'::geometry" % coords.wkt
-        cols['geometry'] = coords
-    for k in cols:
-        if not cols[k]:
-            cols[k] = None
-
-
-def _insert_place_table_nodes(places, force_name):
-    cur = world.conn.cursor()
-    for line in places:
-        cols = dict(line)
-        cols['osm_type'] = 'N'
-        _format_placex_cols(cols, 'POINT', force_name)
-        if 'geometry' in cols:
-            coords = cols.pop('geometry')
-        else:
-            coords = "ST_Point(%f, %f)" % (random.random()*360 - 180, random.random()*180 - 90)
-
-        query = 'INSERT INTO place (%s,geometry) values(%s, ST_SetSRID(%s, 4326))' % (
-              ','.join(cols.iterkeys()),
-              ','.join(['%s' for x in range(len(cols))]),
-              coords
-             )
-        cur.execute(query, cols.values())
-    world.conn.commit()
-
-
-def _insert_place_table_objects(places, geomtype, force_name):
-    cur = world.conn.cursor()
-    for line in places:
-        cols = dict(line)
-        if 'osm_type' not in cols:
-            cols['osm_type'] = 'W'
-        _format_placex_cols(cols, geomtype, force_name)
-        coords = cols.pop('geometry')
-
-        query = 'INSERT INTO place (%s, geometry) values(%s, ST_SetSRID(%s, 4326))' % (
-              ','.join(cols.iterkeys()),
-              ','.join(['%s' for x in range(len(cols))]),
-              coords
-             )
-        cur.execute(query, cols.values())
-    world.conn.commit()
-
-@step(u'the scene (.*)')
-def import_set_scene(step, scene):
-    world.load_scene(scene)
-
-@step(u'the (named )?place (node|way|area)s')
-def import_place_table_nodes(step, named, osmtype):
-    """Insert a list of nodes into the place table.
-       Expects a table where columns are named in the same way as place.
-    """
-    cur = world.conn.cursor()
-    cur.execute('ALTER TABLE place DISABLE TRIGGER place_before_insert')
-    if osmtype == 'node':
-        _insert_place_table_nodes(step.hashes, named is not None)
-    elif osmtype == 'way' :
-        _insert_place_table_objects(step.hashes, 'LINESTRING', named is not None)
-    elif osmtype == 'area' :
-        _insert_place_table_objects(step.hashes, 'POLYGON', named is not None)
-    cur.execute('ALTER TABLE place ENABLE TRIGGER place_before_insert')
-    cur.close()
-    world.conn.commit()
-
-
-@step(u'the relations')
-def import_fill_planet_osm_rels(step):
-    """Adds a raw relation to the osm2pgsql table.
-       Three columns need to be suplied: id, tags, members.
-    """
-    cur = world.conn.cursor()
-    for line in step.hashes:
-        members = []
-        parts = { 'n' : [], 'w' : [], 'r' : [] }
-        if line['members'].strip():
-            for mem in line['members'].split(','):
-                memparts = mem.strip().split(':', 2)
-                memid = memparts[0].lower()
-                parts[memid[0]].append(int(memid[1:]))
-                members.append(memid)
-                if len(memparts) == 2:
-                    members.append(memparts[1])
-                else:
-                    members.append('')
-        tags = []
-        for k,v in world.make_hash(line['tags']).iteritems():
-            tags.extend((k,v))
-        if not members:
-            members = None
-
-        cur.execute("""INSERT INTO planet_osm_rels
-                      (id, way_off, rel_off, parts, members, tags)
-                      VALUES (%s, %s, %s, %s, %s, %s)""",
-                   (line['id'], len(parts['n']), len(parts['n']) + len(parts['w']),
-                   parts['n'] + parts['w'] + parts['r'], members, tags))
-    world.conn.commit()
-        
-
-@step(u'the ways')
-def import_fill_planet_osm_ways(step):
-    cur = world.conn.cursor()
-    for line in step.hashes:
-        if 'tags' in line:
-            tags = world.make_hash(line['tags'])
-        else:
-            tags = None
-        nodes = [int(x.strip()) for x in line['nodes'].split(',')]
-
-        cur.execute("""INSERT INTO planet_osm_ways (id, nodes, tags)
-                       VALUES (%s, %s, %s)""",
-                    (line['id'], nodes, tags))
-    world.conn.commit()
-
-############### import and update steps #######################################
-
-@step(u'importing')
-def import_database(step):
-    """ Runs the actual indexing. """
-    world.run_nominatim_script('setup', 'create-functions', 'create-partition-functions')
-    cur = world.conn.cursor()
-    #world.db_dump_table('place')
-    cur.execute("""insert into placex (osm_type, osm_id, class, type, name, admin_level,
-                   housenumber, street, addr_place, isin, postcode, country_code, extratags,
-                   geometry) select * from place where not (class='place' and type='houses' and osm_type='W')""")
-    cur.execute("""select insert_osmline (osm_id, housenumber, street, addr_place, postcode, country_code, geometry) from place where class='place' and type='houses' and osm_type='W'""")
-    world.conn.commit()
-    world.run_nominatim_script('setup', 'index', 'index-noanalyse')
-    #world.db_dump_table('placex')
-    #world.db_dump_table('location_property_osmline')
-
-@step(u'updating place (node|way|area)s')
-def update_place_table_nodes(step, osmtype):
-    """ Replace a geometry in place by reinsertion and reindex database."""
-    world.run_nominatim_script('setup', 'create-functions', 'create-partition-functions', 'enable-diff-updates')
-    if osmtype == 'node':
-        _insert_place_table_nodes(step.hashes, False)
-    elif osmtype == 'way':
-        _insert_place_table_objects(step.hashes, 'LINESTRING', False)
-    elif osmtype == 'area':
-        _insert_place_table_objects(step.hashes, 'POLYGON', False)
-    world.run_nominatim_script('update', 'index')
-
-@step(u'marking for delete (.*)')
-def update_delete_places(step, places):
-    """ Remove an entry from place and reindex database.
-    """
-    world.run_nominatim_script('setup', 'create-functions', 'create-partition-functions', 'enable-diff-updates')
-    cur = world.conn.cursor()
-    for place in places.split(','):
-        osmtype, osmid, cls = world.split_id(place)
-        if cls is None:
-            q = "delete from place where osm_type = %s and osm_id = %s"
-            params = (osmtype, osmid)
-        else:
-            q = "delete from place where osm_type = %s and osm_id = %s and class = %s"
-            params = (osmtype, osmid, cls)
-        cur.execute(q, params)
-    world.conn.commit()
-    #world.db_dump_table('placex')
-    world.run_nominatim_script('update', 'index')
-
-
-
-@step(u'sending query "(.*)"( with dups)?$')
-def query_cmd(step, query, with_dups):
-    """ Results in standard query output. The same tests as for API queries
-        can be used.
-    """
-    cmd = [os.path.join(world.config.source_dir, 'utils', 'query.php'),
-           '--search', query]
-    if with_dups is not None:
-        cmd.append('--nodedupe')
-    proc = subprocess.Popen(cmd, cwd=world.config.source_dir,
-                            stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-    (outp, err) = proc.communicate()
-    assert (proc.returncode == 0), "query.php failed with message: %s" % err
-    world.page = outp
-    world.response_format = 'json'
-    world.request_type = 'search'
-    world.returncode = 200
-

diff --git a/tests/steps/osm2pgsql_setup.py b/tests/steps/osm2pgsql_setup.py
deleted file mode 100644 (file)
index 4b03b1e..0000000
--- a/tests/steps/osm2pgsql_setup.py
+++ /dev/null
@@ -1,214 +0,0 @@
-""" Steps for setting up a test database for osm2pgsql import.
-
-    Note that osm2pgsql features need a database and therefore need
-    to be tagged with @DB.
-"""
-
-from nose.tools import *
-from lettuce import *
-
-import logging
-import random
-import tempfile
-import os
-import subprocess
-
-logger = logging.getLogger(__name__)
-
-@before.each_scenario
-def osm2pgsql_setup_test(scenario):
-    world.osm2pgsql = []
-
-@step(u'the osm nodes:')
-def osm2pgsql_import_nodes(step):
-    """ Define a list of OSM nodes to be imported, given as a table.
-        Each line describes one node with all its attributes.
-        'id' is mendatory, all other fields are filled with random values
-        when not given. If 'tags' is missing an empty tag list is assumed.
-        For updates, a mandatory 'action' column needs to contain 'A' (add),
-        'M' (modify), 'D' (delete).
-    """
-    for line in step.hashes:
-        node = { 'type' : 'N', 'version' : '1', 'timestamp': "2012-05-01T15:06:20Z",  
-                 'changeset' : "11470653", 'uid' : "122294", 'user' : "foo"
-               }
-        node.update(line)
-        node['id'] = int(node['id'])
-        if 'geometry' in node:
-            lat, lon = node['geometry'].split(' ')
-            node['lat'] = float(lat)
-            node['lon'] = float(lon)
-        else:
-            node['lon'] = random.random()*360 - 180
-            node['lat'] = random.random()*180 - 90
-        if 'tags' in node:
-            node['tags'] = world.make_hash(line['tags'])
-        else:
-            node['tags'] = {}
-
-        world.osm2pgsql.append(node)
-
-
-@step(u'the osm ways:')
-def osm2pgsql_import_ways(step):
-    """ Define a list of OSM ways to be imported.
-    """
-    for line in step.hashes:
-        way = { 'type' : 'W', 'version' : '1', 'timestamp': "2012-05-01T15:06:20Z",  
-                 'changeset' : "11470653", 'uid' : "122294", 'user' : "foo"
-               }
-        way.update(line)
-
-        way['id'] = int(way['id'])
-        if 'tags' in way:
-            way['tags'] = world.make_hash(line['tags'])
-        else:
-            way['tags'] = None
-        way['nodes'] = way['nodes'].strip().split()
-
-        world.osm2pgsql.append(way)
-
-membertype = { 'N' : 'node', 'W' : 'way', 'R' : 'relation' }
-
-@step(u'the osm relations:')
-def osm2pgsql_import_rels(step):
-    """ Define a list of OSM relation to be imported.
-    """
-    for line in step.hashes:
-        rel = { 'type' : 'R', 'version' : '1', 'timestamp': "2012-05-01T15:06:20Z",  
-                 'changeset' : "11470653", 'uid' : "122294", 'user' : "foo"
-               }
-        rel.update(line)
-
-        rel['id'] = int(rel['id'])
-        if 'tags' in rel:
-            rel['tags'] = world.make_hash(line['tags'])
-        else:
-            rel['tags'] = {}
-        members = []
-        if rel['members'].strip():
-            for mem in line['members'].split(','):
-                memparts = mem.strip().split(':', 2)
-                memid = memparts[0].upper()
-                members.append((membertype[memid[0]], 
-                                memid[1:], 
-                                memparts[1] if len(memparts) == 2 else ''
-                              ))
-        rel['members'] = members
-
-        world.osm2pgsql.append(rel)
-
-
-
-def _sort_xml_entries(x, y):
-    if x['type'] == y['type']:
-        return cmp(x['id'], y['id'])
-    else:
-        return cmp('NWR'.find(x['type']), 'NWR'.find(y['type']))
-
-def write_osm_obj(fd, obj):
-    if obj['type'] == 'N':
-        fd.write('<node id="%(id)d" lat="%(lat).8f" lon="%(lon).8f" version="%(version)s" timestamp="%(timestamp)s" changeset="%(changeset)s" uid="%(uid)s" user="%(user)s"'% obj)
-        if obj['tags'] is None:
-            fd.write('/>\n')
-        else:
-            fd.write('>\n')
-            for k,v in obj['tags'].iteritems():
-                fd.write('  <tag k="%s" v="%s"/>\n' % (k, v))
-            fd.write('</node>\n')
-    elif obj['type'] == 'W':
-        fd.write('<way id="%(id)d" version="%(version)s" changeset="%(changeset)s" timestamp="%(timestamp)s" user="%(user)s" uid="%(uid)s">\n' % obj)
-        for nd in obj['nodes']:
-            fd.write('<nd ref="%s" />\n' % (nd,))
-        for k,v in obj['tags'].iteritems():
-            fd.write('  <tag k="%s" v="%s"/>\n' % (k, v))
-        fd.write('</way>\n')
-    elif obj['type'] == 'R':
-        fd.write('<relation id="%(id)d" version="%(version)s" changeset="%(changeset)s" timestamp="%(timestamp)s" user="%(user)s" uid="%(uid)s">\n' % obj)
-        for mem in obj['members']:
-            fd.write('  <member type="%s" ref="%s" role="%s"/>\n' % mem)
-        for k,v in obj['tags'].iteritems():
-            fd.write('  <tag k="%s" v="%s"/>\n' % (k, v))
-        fd.write('</relation>\n')
-
-@step(u'loading osm data')
-def osm2pgsql_load_place(step):
-    """Imports the previously defined OSM data into a fresh copy of a
-       Nominatim test database.
-    """
-
-    world.osm2pgsql.sort(cmp=_sort_xml_entries)
-
-    # create a OSM file in /tmp
-    with tempfile.NamedTemporaryFile(dir='/tmp', suffix='.osm', delete=False) as fd:
-        fname = fd.name
-        fd.write("<?xml version='1.0' encoding='UTF-8'?>\n")
-        fd.write('<osm version="0.6" generator="test-nominatim" timestamp="2014-08-26T20:22:02Z">\n')
-        fd.write('\t<bounds minlat="43.72335" minlon="7.409205" maxlat="43.75169" maxlon="7.448637"/>\n')
-        
-        for obj in world.osm2pgsql:
-            write_osm_obj(fd, obj)
-
-        fd.write('</osm>\n')
-
-    logger.debug( "Filename: %s" % fname)
-
-    cmd = [os.path.join(world.config.source_dir, 'utils', 'setup.php')]
-    cmd.extend(['--osm-file', fname, '--import-data','--osm2pgsql-cache', '300'])
-    proc = subprocess.Popen(cmd, cwd=world.config.source_dir,
-                            stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-    (outp, outerr) = proc.communicate()
-    assert (proc.returncode == 0), "OSM data import failed:\n%s\n%s\n" % (outp, outerr)
-
-    ### reintroduce the triggers/indexes we've lost by having osm2pgsql set up place again
-    cur = world.conn.cursor()
-    cur.execute("""CREATE TRIGGER place_before_delete BEFORE DELETE ON place
-                    FOR EACH ROW EXECUTE PROCEDURE place_delete()""")
-    cur.execute("""CREATE TRIGGER place_before_insert BEFORE INSERT ON place
-                   FOR EACH ROW EXECUTE PROCEDURE place_insert()""")
-    cur.execute("""CREATE UNIQUE INDEX idx_place_osm_unique on place using btree(osm_id,osm_type,class,type)""")
-    world.conn.commit()
-
-        
-    os.remove(fname)
-    world.osm2pgsql = []
-
-actiontypes = { 'C' : 'create', 'M' : 'modify', 'D' : 'delete' }
-
-@step(u'updating osm data')
-def osm2pgsql_update_place(step):
-    """Creates an osc file from the previously defined data and imports it
-       into the database.
-    """
-    world.run_nominatim_script('setup', 'create-functions', 'create-partition-functions')
-    cur = world.conn.cursor()
-    cur.execute("""insert into placex (osm_type, osm_id, class, type, name, admin_level,
-                              housenumber, street, addr_place, isin, postcode, country_code, extratags,
-                              geometry) select * from place""")
-    world.conn.commit()
-    world.run_nominatim_script('setup', 'index', 'index-noanalyse')
-    world.run_nominatim_script('setup', 'create-functions', 'create-partition-functions', 'enable-diff-updates')
-
-    with tempfile.NamedTemporaryFile(dir='/tmp', suffix='.osc', delete=False) as fd:
-        fname = fd.name
-        fd.write("<?xml version='1.0' encoding='UTF-8'?>\n")
-        fd.write('<osmChange version="0.6" generator="Osmosis 0.43.1">\n')
-
-        for obj in world.osm2pgsql:
-            fd.write('<%s>\n' % (actiontypes[obj['action']], ))
-            write_osm_obj(fd, obj)
-            fd.write('</%s>\n' % (actiontypes[obj['action']], ))
-
-        fd.write('</osmChange>\n')
-
-    logger.debug( "Filename: %s" % fname)
-
-    cmd = [os.path.join(world.config.source_dir, 'utils', 'update.php')]
-    cmd.extend(['--import-diff', fname])
-    proc = subprocess.Popen(cmd, cwd=world.config.source_dir,
-                            stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-    (outp, outerr) = proc.communicate()
-    assert (proc.returncode == 0), "OSM data update failed:\n%s\n%s\n" % (outp, outerr)
-
-    os.remove(fname)
-    world.osm2pgsql = []

diff --git a/tests/steps/terrain.py b/tests/steps/terrain.py
deleted file mode 100644 (file)
index 80beebd..0000000
--- a/tests/steps/terrain.py
+++ /dev/null
@@ -1,255 +0,0 @@
-from lettuce import *
-from nose.tools import *
-import logging
-import os
-import subprocess
-import psycopg2
-import re
-from haversine import haversine
-from shapely.wkt import loads as wkt_load
-from shapely.ops import linemerge
-
-logger = logging.getLogger(__name__)
-
-class NominatimConfig:
-
-    def __init__(self):
-        # logging setup
-        loglevel = getattr(logging, os.environ.get('LOGLEVEL','info').upper())
-        if 'LOGFILE' in os.environ:
-            logging.basicConfig(filename=os.environ.get('LOGFILE','run.log'),
-                                level=loglevel)
-        else:
-            logging.basicConfig(level=loglevel)
-        # Nominatim test setup
-        self.base_url = os.environ.get('NOMINATIM_SERVER', 'http://localhost/nominatim')
-        self.source_dir = os.path.abspath(os.environ.get('NOMINATIM_DIR', '../build'))
-        self.template_db = os.environ.get('TEMPLATE_DB', 'test_template_nominatim')
-        self.test_db = os.environ.get('TEST_DB', 'test_nominatim')
-        self.local_settings_file = os.environ.get('NOMINATIM_SETTINGS', '/tmp/nominatim_settings.php')
-        self.reuse_template = 'NOMINATIM_REMOVE_TEMPLATE' not in os.environ
-        self.keep_scenario_db = 'NOMINATIM_KEEP_SCENARIO_DB' in os.environ
-        os.environ['NOMINATIM_SETTINGS'] = '/tmp/nominatim_settings.php'
-
-        scriptpath = os.path.dirname(os.path.abspath(__file__))
-        self.scene_path = os.environ.get('SCENE_PATH', 
-                os.path.join(scriptpath, '..', 'scenes', 'data'))
-
-
-    def __str__(self):
-        return 'Server URL: %s\nSource dir: %s\n' % (self.base_url, self.source_dir)
-
-world.config = NominatimConfig()
-
-@world.absorb
-def write_nominatim_config(dbname):
-    f = open(world.config.local_settings_file, 'w')
-    f.write("<?php\n  @define('CONST_Database_DSN', 'pgsql://@/%s');\n" % dbname)
-    f.close()
-
-
-@world.absorb
-def run_nominatim_script(script, *args):
-    cmd = [os.path.join(world.config.source_dir, 'utils', '%s.php' % script)]
-    cmd.extend(['--%s' % x for x in args])
-    proc = subprocess.Popen(cmd, cwd=world.config.source_dir,
-                            stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-    (outp, outerr) = proc.communicate()
-    logger.debug("run_nominatim_script: %s\n%s\n%s" % (cmd, outp, outerr))
-    assert (proc.returncode == 0), "Script '%s' failed:\n%s\n%s\n" % (script, outp, outerr)
-
-@world.absorb
-def make_hash(inp):
-    return eval('{' + inp + '}')
-
-@world.absorb
-def split_id(oid):
-    """ Splits a unique identifier for places into its components.
-        As place_ids cannot be used for testing, we use a unique
-        identifier instead that is of the form <osmtype><osmid>[:class].
-    """
-    oid = oid.strip()
-    if oid == 'None':
-        return None, None, None
-    osmtype = oid[0]
-    assert_in(osmtype, ('R','N','W'))
-    if ':' in oid:
-        osmid, cls = oid[1:].split(':')
-        return (osmtype, int(osmid), cls)
-    else:
-        return (osmtype, int(oid[1:]), None)
-
-@world.absorb
-def get_placeid(oid):
-    """ Tries to retrive the place_id for a unique identifier. """
-    if oid[0].isdigit():
-        return int(oid)
-
-    osmtype, osmid, cls = world.split_id(oid)
-    if osmtype is None:
-        return None
-    cur = world.conn.cursor()
-    if cls is None:
-        q = 'SELECT place_id FROM placex where osm_type = %s and osm_id = %s'
-        params = (osmtype, osmid)
-    else:
-        q = 'SELECT place_id FROM placex where osm_type = %s and osm_id = %s and class = %s'
-        params = (osmtype, osmid, cls)
-    cur.execute(q, params)
-    assert_equals(cur.rowcount, 1, "%d rows found for place %s" % (cur.rowcount, oid))
-    return cur.fetchone()[0]
-
-
-@world.absorb
-def match_geometry(coord, matchstring):
-    m = re.match(r'([-0-9.]+),\s*([-0-9.]+)\s*(?:\+-([0-9.]+)([a-z]+)?)?', matchstring)
-    assert_is_not_none(m, "Invalid match string")
-
-    logger.debug("Distmatch: %s/%s %s %s" % (m.group(1), m.group(2), m.group(3), m.group(4) ))
-    dist = haversine(coord, (float(m.group(1)), float(m.group(2))))
-
-    if m.group(3) is not None:
-        expdist = float(m.group(3))
-        if m.group(4) is not None:
-            if m.group(4) == 'm':
-                expdist = expdist/1000
-            elif m.group(4) == 'km':
-                pass
-            else:
-                raise Exception("Unknown unit '%s' in geometry match" % (m.group(4), ))
-    else:
-        expdist = 0
-
-    logger.debug("Distances expected: %f, got: %f" % (expdist, dist))
-    assert dist <= expdist, "Geometry too far away, expected: %f, got: %f" % (expdist, dist)
-
-@world.absorb
-def print_statement(element):
-    print '\n\n\n'+str(element)+'\n\n\n'
-
-
-@world.absorb
-def db_dump_table(table):
-    cur = world.conn.cursor()
-    cur.execute('SELECT * FROM %s' % table)
-    print '\n\n\n<<<<<<< BEGIN OF TABLE DUMP %s' % table
-    for res in cur:
-            print res
-    print '<<<<<<< END OF TABLE DUMP %s\n\n\n' % table
-
-@world.absorb
-def db_drop_database(name):
-    conn = psycopg2.connect(database='postgres')
-    conn.set_isolation_level(0)
-    cur = conn.cursor()
-    cur.execute('DROP DATABASE IF EXISTS %s' % (name, ))
-    conn.close()
-
-
-world.is_template_set_up = False
-
-@world.absorb
-def db_template_setup():
-    """ Set up a template database, containing all tables
-        but not yet any functions.
-    """
-    if world.is_template_set_up:
-        return
-
-    world.is_template_set_up = True
-    world.write_nominatim_config(world.config.template_db)
-    if world.config.reuse_template:
-        # check that the template is there
-        conn = psycopg2.connect(database='postgres')
-        cur = conn.cursor()
-        cur.execute('select count(*) from pg_database where datname = %s', 
-                     (world.config.template_db,))
-        if cur.fetchone()[0] == 1:
-            return
-    else:
-        # just in case... make sure a previous table has been dropped
-        world.db_drop_database(world.config.template_db)
-    # call the first part of database setup
-    world.run_nominatim_script('setup', 'create-db', 'setup-db')
-    # remove external data to speed up indexing for tests
-    conn = psycopg2.connect(database=world.config.template_db)
-    psycopg2.extras.register_hstore(conn, globally=False, unicode=True)
-    cur = conn.cursor()
-    for table in ('gb_postcode', 'us_postcode'):
-        cur.execute("select * from pg_tables where tablename = '%s'" % (table, ))
-        if cur.rowcount > 0:
-            cur.execute('TRUNCATE TABLE %s' % (table,))
-    conn.commit()
-    conn.close()
-    # execute osm2pgsql on an empty file to get the right tables
-    osm2pgsql = os.path.join(world.config.source_dir, 'osm2pgsql', 'osm2pgsql')
-    proc = subprocess.Popen([osm2pgsql, '-lsc', '-r', 'xml', '-O', 'gazetteer', '-d', world.config.template_db, '-'],
-                            cwd=world.config.source_dir, stdin=subprocess.PIPE,
-                            stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-    [outstr, errstr] = proc.communicate(input='<osm version="0.6"></osm>')
-    logger.debug("running osm2pgsql for template: %s\n%s\n%s" % (osm2pgsql, outstr, errstr))
-    world.run_nominatim_script('setup', 'create-functions', 'create-tables', 'create-partition-tables', 'create-partition-functions', 'load-data', 'create-search-indices')
-
-
-# Leave the table around so it can be reused again after a non-reuse test round.
-#@after.all
-def db_template_teardown(total):
-    """ Set up a template database, containing all tables
-        but not yet any functions.
-    """
-    if world.is_template_set_up:
-        # remove template DB
-        if not world.config.reuse_template:
-            world.db_drop_database(world.config.template_db)
-        try:
-            os.remove(world.config.local_settings_file)
-        except OSError:
-            pass # ignore missing file
-
-
-##########################################################################
-#
-# Data scene handling
-#
-
-world.scenes = {}
-world.current_scene = None
-
-@world.absorb
-def load_scene(name):
-    if name in world.scenes:
-        world.current_scene = world.scenes[name]
-    else:
-        with open(os.path.join(world.config.scene_path, "%s.wkt" % name), 'r') as fd:
-            scene = {}
-            for line in fd:
-                if line.strip():
-                    obj, wkt = line.split('|', 2)
-                    wkt = wkt.strip()
-                    scene[obj.strip()] = wkt_load(wkt)
-            world.scenes[name] = scene
-            world.current_scene = scene
-
-@world.absorb
-def get_scene_geometry(name):
-    if not ':' in name:
-        # Not a scene description
-        return None
-    
-    geoms = []
-    for obj in name.split('+'):
-        oname = obj.strip()
-        if oname.startswith(':'):
-            geoms.append(world.current_scene[oname[1:]])
-        else:
-            scene, obj = oname.split(':', 2)
-            oldscene = world.current_scene
-            world.load_scene(scene)
-            wkt = world.current_scene[obj]
-            world.current_scene = oldscene
-            geoms.append(wkt)
-
-    if len(geoms) == 1:
-        return geoms[0]
-    else:
-        return linemerge(geoms)