def test_valid_success_response():
foo = FeatureBuilder() \
.set_query('foo') \
.set_id('bar') \
.set_name('baz') \
.set_boundary(Polygon([Ring([GeoPoint(1, 2), GeoPoint(3, 4), GeoPoint(5, 6), GeoPoint(7, 8)])])) \
.set_centroid(GeoPoint(9, 10)) \
.set_limit(GeoRect(11, 12, 13, 14)) \
.set_position(GeoRect(15, 16, 17, 18)) \
.build_geocoded()
foofoo = FeatureBuilder() \
.set_query('foofoo') \
.set_id('barbar') \
.set_name('bazbaz') \
.build_geocoded()
response_dict = ResponseFormatter.format(
ResponseBuilder() \
.set_status(Status.success) \
.set_message('OK') \
.set_level(LevelKind.city) \
.set_geocoded_features([foo, foofoo])
.build()
)
response = ResponseParser.parse(response_dict)
assert isinstance(response, SuccessResponse)
assert 'OK' == response.message
assert 2 == len(response.answers)
assert_geocoded(foo, response.answers[0].features[0])
assert_geocoded(foofoo, response.answers[1].features[0])
def test_where_closets_to_point():
request = geocode(names=['foo']) \
.states(['bar']) \
.where(name='foo', state='bar', closest_to=shapely.geometry.Point(1, 2)) \
._build_request()
assert_that(request) \
.has_query(QueryMatcher()
.with_name('foo')
.state(eq_map_region_with_name('bar'))
.ambiguity_resolver(eq(AmbiguityResolver(closest_coord=GeoPoint(1, 2))))
)
def test_allow_ambiguous_and_closest_to():
request = geocode(names=['foo', 'bar'])\
.where('foo', closest_to=shapely.geometry.Point(1, 2))\
.allow_ambiguous()\
._build_request()
assert_that(request) \
.allows_ambiguous()\
.has_query(QueryMatcher()
.with_name('foo')
.ambiguity_resolver(eq(AmbiguityResolver(closest_coord=GeoPoint(1, 2))))
) \
.has_query(QueryMatcher()
.with_name('bar')
.ambiguity_resolver(eq(AmbiguityResolver(ignoring_strategy=IgnoringStrategyKind.take_namesakes)))
)
def test_ambiguity_resolver():
foo = _query(request='foo', ambiguity_resolver=AmbiguityResolver(closest_coord=GeoPoint(1, 2)))
request: GeocodingRequest = RequestBuilder() \
.set_request_kind(RequestKind.geocoding) \
.set_namesake_limit(10) \
.set_queries([foo]) \
.build()
json = RequestFormatter().format(request).to_dict()
parsed_request = RequestParser().parse(json)
assert isinstance(parsed_request, GeocodingRequest)
assert 1 == len(parsed_request.region_queries)
assert_region_query(foo, parsed_request.region_queries[0])
def test_reverse_request():
request: ReverseGeocodingRequest = RequestBuilder() \
.set_request_kind(RequestKind.reverse) \
.set_reverse_coordinates([GeoPoint(1.0, 2.0)]) \
.set_level(LevelKind.city) \
.set_reverse_scope(MapRegion.with_name('foo_region')) \
.set_resolution(123) \
.set_requested_payload([PayloadKind.boundaries, PayloadKind.centroids]) \
.build()
json = RequestFormatter().format(request).to_dict()
parsed_request: ReverseGeocodingRequest = RequestParser().parse(json)
assert isinstance(parsed_request, ReverseGeocodingRequest)
assert request.requested_payload == parsed_request.requested_payload
assert request.resolution == parsed_request.resolution
assert request.coordinates == parsed_request.coordinates
assert request.level == parsed_request.level
assert request.scope == parsed_request.scope
assert_that(request) \
.has_query(QueryMatcher()
.with_name('foo')
.state(eq_map_region_with_name('bar'))
.ambiguity_resolver(eq(AmbiguityResolver(closest_coord=GeoPoint(1, 2))))
)
@mock.patch.object(
GeocodingService, 'do_request', lambda self, reqest: SuccessResponse(
message='',
level=LevelKind.city,
answers=[
Answer(features=[
GeocodedFeature(
id='foo_id', name='foo', centroid=GeoPoint(1, 2))
])
]))
def test_where_closest_to_region():
request = geocode(names=['foo']) \
.states(['bar']) \
.where(name='foo', state='bar', closest_to=make_simple_region('foo', 'foo_id')) \
._build_request()
assert_that(request) \
.has_query(QueryMatcher()
.with_name('foo')
.state(eq_map_region_with_name('bar'))
.ambiguity_resolver(eq(AmbiguityResolver(closest_coord=GeoPoint(1, 2))))
)