def test_regions_with_highlights(mock_geocoding):
try:
regions_builder(level=LEVEL,
request=FILTER_LIST,
within=REGION_NAME,
highlights=True).build()
except Exception:
pass # response doesn't contain proper feature with ids - ignore
mock_geocoding.assert_called_with(
GeocodingRequest(requested_payload=[PayloadKind.highlights],
resolution=None,
region_queries=[REGION_QUERY_LA, REGION_QUERY_NY],
level=LEVEL_KIND,
namesake_example_limit=NAMESAKES_EXAMPLE_LIMIT))
def test_empty():
actual = \
regions_builder()._get_queries()
expected = [query()]
assert expected == actual
def test_positional_empty():
actual = \
regions_builder(request=[])._get_queries()
expected = [query()]
assert expected == actual
def test_ambiguity_drop_not_matched():
r = geodata.regions_builder(level='city', request=['gotham', 'new york city', 'manchester']) \
.drop_not_matched() \
.build()
actual = r.to_data_frame()[DF_FOUND_NAME].tolist()
assert ['New York City'] == actual
def test_ambiguity_allow_ambiguous():
r = geodata.regions_builder(level='city', request=['gotham', 'new york city', 'manchester']) \
.allow_ambiguous() \
.build()
actual = r.to_data_frame()[DF_FOUND_NAME].tolist()
assert 28 == len(actual) # 1 New York City + 27 Manchester
def test_positional_with_duplicated_queries_and_regions():
actual = regions_builder(request=names(FOO, FOO),
within=regions_list(FOO, FOO))._get_queries()
expected = [query(FOO.name, FOO.region), query(FOO.name, FOO.region)]
assert expected == actual
def test_near_shapely_point():
actual = \
regions_builder(request=names(FOO, BAR)) \
.where(names(BAR), near=ShapelyPoint(1., 2.)) \
._get_queries()
expected = [query(FOO.name), query(BAR.name, near=GeoPoint(1., 2.))]
assert expected == actual
def test_list_duplication_with_overriding_duplication():
actual = \
regions_builder(request=names(FOO, FOO)) \
.where(names(FOO, FOO)) \
._get_queries()
expected = [query(FOO.name), query(FOO.name)]
assert expected == actual
def test_list_chaining_with_addition():
actual = \
regions_builder(request=names(FOO, BAR)) \
.where(names(BAZ), single_region(BAZ)) \
._get_queries()
expected = [query(FOO.name), query(BAR.name), query(BAZ.name, BAZ.region)]
assert expected == actual
def test_single_chaining_with_overriding():
actual = \
regions_builder(request=names(FOO, BAR)) \
.where(names(BAR), single_region(BAR)) \
._get_queries()
expected = [query(FOO.name), query(BAR.name, BAR.region)]
assert expected == actual
def test_simple_positional():
actual = \
regions_builder(
request=names(FOO, BAR),
within=regions_list(FOO, BAR)
)._get_queries()
expected = [query(FOO.name, FOO.region), query(BAR.name, BAR.region)]
assert expected == actual
def test_with_regions():
actual = \
regions_builder(
request=names(FOO),
within=Regions(LevelKind.city, [FOO.feature])) \
._get_queries()
expected = [query(FOO.name, FOO.region)]
assert expected == actual
def test_ambiguity_drop_not_found():
try:
r = geodata.regions_builder(level='city', request=['gotham', 'new york city', 'manchester']) \
.drop_not_found() \
.build()
except ValueError as ex:
str(ex).startswith('Multiple objects (27) were found for manchester')
return
assert False, 'Should throw exception'
def test_override_twice():
actual = \
regions_builder(request=names(FOO)) \
.where(names(FOO), single_region(FOO)) \
.where(names(FOO), 'foofoo_region') \
._get_queries()
expected = [query(FOO.name, 'foofoo_region')]
assert expected == actual
def test_ambiguity_near_boston_by_coord():
r = geodata.regions_builder(
level='city',
request='Warwick'
) \
.where('Warwick', near=ShapelyPoint(BOSTON_LON, BOSTON_LAT)) \
.build()
assert_row(r.to_data_frame(), id=WARWICK_ID, found_name='Warwick')
assert_row(r.centroids(), lon=WARWICK_LON, lat=WARWICK_LAT)
def test_havana_new_york():
try:
r = geodata.regions_builder(request=['havana', 'new york city']) \
.where(request='havana', within=geodata.regions_country('cuba')) \
.where(request='new york city', within=geodata.regions_state('new york')) \
.build()
except ValueError as ex:
assert 'No objects were found for new york city.\n' == str(ex)
return
assert False, 'Should throw exception'
def test_positional_where_full_replace():
actual = \
regions_builder(
request=names(FOO, BAR)
) \
.where(names(FOO, BAR), regions_list(FOO, BAR)) \
._get_queries()
expected = [query(FOO.name, FOO.region), query(BAR.name, BAR.region)]
assert expected == actual
def test_where_request_level_detection():
"""
where('new york', region=geodata.regions_state('new york')) gives county as first detected level
where('boston', region=geodata.regions_country('usa')) gives city as first detected level
But 'new york' also matches a city name so common level should be a city
"""
r = geodata.regions_builder(request=['new york', 'boston']) \
.where('new york', within=geodata.regions_state('new york')) \
.where('boston', within=geodata.regions_country('usa')) \
.build()
assert [NYC_ID, BOSTON_ID] == r.to_data_frame().id.tolist()
def test_only_default_ignoring_strategy():
actual = \
regions_builder(request=names(FOO, BAR)) \
.allow_ambiguous() \
._get_queries()
expected = [
query(FOO.name, ignoring_strategy=IgnoringStrategyKind.take_namesakes),
query(BAR.name, ignoring_strategy=IgnoringStrategyKind.take_namesakes)
]
assert expected == actual
def test_within_shapely_box():
actual = \
regions_builder(request=names(FOO, BAR)) \
.where(names(BAR), within=shapely.geometry.box(0, 1, 2, 3)) \
._get_queries()
expected = [
query(FOO.name),
query(BAR.name,
box=GeoRect(min_lon=0, min_lat=1, max_lon=2, max_lat=3))
]
assert expected == actual
def test_positional_ctor_with_duplicated_queries_and_different_regions():
actual = \
regions_builder(
request=names(FOO, FOO_NAMESAKE),
within=regions_list(FOO, FOO_NAMESAKE),
)._get_queries()
expected = [
query(FOO.name, FOO.region),
query(FOO_NAMESAKE.name, FOO_NAMESAKE.region)
]
assert expected == actual
def test_order_with_positional_where():
actual = \
regions_builder(
request=names(FOO, BAR, BAZ)
) \
.where(names(BAR), regions_list(BAR)) \
.where(names(BAZ, FOO), regions_list(BAZ, FOO)) \
._get_queries()
expected = [
query(FOO.name, FOO.region),
query(BAR.name, BAR.region),
query(BAZ.name, BAZ.region)
]
assert expected == actual
def test_missing_address(address, drop_not_found, found, error):
# use_local_server()
builder = geodata.regions_builder(level='city',
request=address,
within='usa')
if drop_not_found:
builder.drop_not_found()
if error is not None:
try:
builder.build()
except ValueError as e:
assert str(e).startswith(error)
else:
r = builder.build()
assert_found_names(r.to_data_frame(), found)
def test_near_to_region(mock_request):
mock_request.return_value = make_success_response() \
.set_geocoded_features(
[
feature(BAZ).set_centroid(GeoPoint(1, 2)).build_geocoded()
]
).build()
actual = \
regions_builder(request=names(FOO, BAR)) \
.where(names(BAR), near=single_region(BAZ)) \
._get_queries()
expected = [query(FOO.name), query(BAR.name, near=GeoPoint(1, 2))]
assert expected == actual
def test_order_with_where():
actual = \
regions_builder(
request=names(FOO, BAR, BAZ)
) \
.where(names(BAR), regions_list(BAR)) \
.where(names(BAZ, FOO), single_region(BAZ, FOO)) \
._get_queries()
expected = [
query(FOO.name, map_region([BAZ, FOO])),
query(BAR.name, BAR.region),
query(BAZ.name, map_region([BAZ, FOO]))
]
assert expected == actual
def test_controversy_positional_where_with_duplicated_queries_and_different_regions(
):
# We have to add duplicated objects with properly set regions. It's imposible to fix it later
actual = \
regions_builder(
request=names(FOO, FOO_NAMESAKE)
).where(
request=names(FOO, FOO_NAMESAKE),
within=regions_list(FOO, FOO_NAMESAKE)
)._get_queries()
expected = [
query(FOO.name, FOO_NAMESAKE.region),
query(FOO_NAMESAKE.name, FOO_NAMESAKE.region)
]
assert expected == actual
def test_ambiguity_near_boston_by_box():
boston = geodata.regions_city('boston').centroids().iloc[[0]]
buffer = 0.6
boston_centroid = ShapelyPoint(boston.geometry.x, boston.geometry.y)
r = geodata.regions_builder(
level='city',
request='Warwick'
) \
.where('Warwick',
within=shapely.geometry.box(
boston_centroid.x - buffer,
boston_centroid.y - buffer,
boston_centroid.x + buffer,
boston_centroid.y + buffer
)) \
.build()
assert_row(r.to_data_frame(), id=WARWICK_ID, found_name='Warwick')
assert_row(r.centroids(), lon=WARWICK_LON, lat=WARWICK_LAT)
def test_near_with_default_ignoring_strategy(mock_request):
mock_request.return_value = make_success_response() \
.set_geocoded_features(
[
feature(BAZ).set_centroid(GeoPoint(1., 2.)).build_geocoded()
]
).build()
actual = \
regions_builder(request=names(FOO, BAR)) \
.allow_ambiguous() \
.where(names(BAR), near=single_region(BAZ)) \
._get_queries()
expected = [
query(FOO.name, ignoring_strategy=IgnoringStrategyKind.take_namesakes),
query(BAR.name, near=GeoPoint(1., 2.), ignoring_strategy=None)
]
assert expected == actual
def test_ctor():
actual = \
regions_builder(request=names(FOO), within=single_region(FOO)) \
._get_queries()
expected = [query(FOO.name, FOO.region)]
assert expected == actual
def test_positional_wrong_size():
try:
regions_builder(request=names(FOO, BAR))._get_queries()
except ValueError as e:
assert 'Length of filter and region is not equal' == str(e)
