desc
stringlengths 3
26.7k
| decl
stringlengths 11
7.89k
| bodies
stringlengths 8
553k
|
|---|---|---|
'OpenMapQuest.geocode unicode'
| def test_unicode_name(self):
| self.geocode_run({'query': u('\\u6545\\u5bab')}, {'latitude': 39.916, 'longitude': 116.39})
|
'get_geocoder_for_service'
| def test_ok(self):
| self.assertEqual(get_geocoder_for_service('google'), GoogleV3)
self.assertEqual(get_geocoder_for_service('googlev3'), GoogleV3)
|
'get_geocoder_for_service unknown service'
| def test_fail(self):
| with self.assertRaises(GeocoderNotFound):
get_geocoder_for_service('')
|
'Geocoder()'
| def test_init(self):
| format_string = '%s Los Angeles, CA USA'
scheme = 'http'
timeout = (DEFAULT_TIMEOUT + 1)
proxies = {'https': '192.0.2.0'}
geocoder = Geocoder(format_string=format_string, scheme=scheme, timeout=timeout, proxies=proxies)
for attr in ('format_string', 'scheme', 'timeout', 'proxies'):
self.assertEqual(locals()[attr], getattr(geocoder, attr))
|
'Geocoder._coerce_point_to_string Point'
| def test_point_coercion_point(self):
| self.assertEqual(self.geocoder._coerce_point_to_string(Point(*self.coordinates)), self.coordinates_str)
|
'Geocoder._coerce_point_to_string tuple of coordinates'
| def test_point_coercion_floats(self):
| self.assertEqual(self.geocoder._coerce_point_to_string(self.coordinates), self.coordinates_str)
|
'Geocoder._coerce_point_to_string string of coordinates'
| def test_point_coercion_string(self):
| self.assertEqual(self.geocoder._coerce_point_to_string(self.coordinates_str), self.coordinates_str)
|
'Geocoder._coerce_point_to_string address string'
| def test_point_coercion_address(self):
| self.assertEqual(self.geocoder._coerce_point_to_string(self.coordinates_address), self.coordinates_address)
|
'Yandex.geocode unicode'
| def test_unicode_name(self):
| self.geocoder = Yandex()
self.geocode_run({u'query': u'\u043f\u043b\u043e\u0449\u0430\u0434\u044c \u041b\u0435\u043d\u0438\u043d\u0430 \u0414\u043e\u043d\u0435\u0446\u043a'}, {u'latitude': 48.002104, u'longitude': 37.805186})
|
'Yandex.reverse'
| def test_reverse(self):
| self.geocoder = Yandex()
self.reverse_run({u'query': u'40.75376406311989, -73.98489005863667'}, {u'latitude': 40.75376406311989, u'longitude': (-73.98489005863667)})
|
'Yandex.geocode with api_key and lang set'
| def test_params(self):
| self.geocoder = Yandex(api_key=u'AGg6X1QBAAAAk0ZiFwIAUfmxqDgGv6n7bhzuCl5D4MC31ZoAAAAAAAAAAADSboKTjoZyt88aQGXUGHUdJ3JHqQ==', lang=u'uk_UA')
self.geocode_run({u'query': u'\u043f\u043b\u043e\u0449\u0430 \u041b\u0435\u043d\u0456\u043d\u0430 \u0414\u043e\u043d\u0435\u0446\u044c\u043a'}, {u'raw': {u'metaDataProperty': {u'GeocoderMetaData': {u'kind': u'street', u'text': u'\u0423\u043a\u0440\u0430\u0457\u043d\u0430, \u0414\u043e\u043d\u0435\u0446\u044c\u043a, \u043f\u043b\u043e\u0449\u0430 \u041b\u0435\u043d\u0456\u043d\u0430', u'precision': u'street', u'AddressDetails': {u'Country': {u'AddressLine': u'\u0414\u043e\u043d\u0435\u0446\u044c\u043a, \u043f\u043b\u043e\u0449\u0430 \u041b\u0435\u043d\u0456\u043d\u0430', u'CountryNameCode': u'UA', u'CountryName': u'\u0423\u043a\u0440\u0430\u0457\u043d\u0430', u'AdministrativeArea': {u'AdministrativeAreaName': u'\u0414\u043e\u043d\u0435\u0446\u044c\u043a\u0430 \u043e\u0431\u043b\u0430\u0441\u0442\u044c', u'SubAdministrativeArea': {u'SubAdministrativeAreaName': u'\u0414\u043e\u043d\u0435\u0446\u044c\u043a\u0430 \u043c\u0456\u0441\u044c\u043a\u0430 \u0440\u0430\u0434\u0430', u'Locality': {u'LocalityName': u'\u0414\u043e\u043d\u0435\u0446\u044c\u043a', u'Thoroughfare': {u'ThoroughfareName': u'\u043f\u043b\u043e\u0449\u0430 \u041b\u0435\u043d\u0456\u043d\u0430'}}}}}}}}, u'description': u'\u0414\u043e\u043d\u0435\u0446\u044c\u043a, \u0423\u043a\u0440\u0430\u0457\u043d\u0430', u'name': u'\u043f\u043b\u043e\u0449\u0430 \u041b\u0435\u043d\u0456\u043d\u0430', u'boundedBy': {u'Envelope': {u'lowerCorner': u'37.804575 48.001669', u'upperCorner': u'37.805805 48.002538'}}, u'Point': {u'pos': u'37.805186 48.002104'}}})
|
'GeoNames.geocode unicode'
| def test_unicode_name(self):
| self.geocoder = GeoNames(username=env['GEONAMES_USERNAME'])
self.geocode_run({'query': 'Mount Everest, Nepal'}, {'latitude': 27.987, 'longitude': 86.925})
|
'GeoNames.reverse'
| def test_reverse(self):
| self.geocoder = GeoNames(username=env['GEONAMES_USERNAME'])
self.reverse_run({'query': '40.75376406311989, -73.98489005863667'}, {'latitude': 40.75376406311989, 'longitude': (-73.98489005863667)})
|
'ArcGIS.__init__ invalid authentication'
| def test_config_error(self):
| with self.assertRaises(exc.ConfigurationError):
ArcGIS(username='a')
|
'ArcGIS.__init__ invalid scheme'
| def test_scheme_config_error(self):
| with self.assertRaises(exc.ConfigurationError):
ArcGIS(username='a', password='b', referer='http://www.example.com', scheme='http')
|
'ArcGIS.geocode'
| def test_geocode(self):
| self.geocode_run({'query': '435 north michigan ave, chicago il 60611 usa'}, {'latitude': 41.89, 'longitude': (-87.624)})
|
'ArcGIS.geocode unicode'
| def test_unicode_name(self):
| self.geocode_run({'query': u('\\u6545\\u5bab')}, {'latitude': 39.916, 'longitude': 116.39})
|
'ArcGIS.reverse using point'
| def test_reverse_point(self):
| self.reverse_run({'query': Point(40.753898, (-73.985071))}, {'latitude': 40.75376406311989, 'longitude': (-73.98489005863667)})
|
'ArcGIS.geocode using authentication'
| def test_basic_address(self):
| self.geocode_run({'query': 'Potsdamer Platz, Berlin, Deutschland'}, {'latitude': 52.5094982, 'longitude': 13.3765983})
|
'Calls geocoder.geocode(**payload), then checks against `expected`.'
| def geocode_run(self, payload, expected, expect_failure=False):
| result = self._make_request(self.geocoder.geocode, **payload)
if (result is None):
if (not expect_failure):
self.fail('No result found')
else:
return
self._verify_request(result, **expected)
|
'Calls geocoder.reverse(**payload), then checks against `expected`.'
| def reverse_run(self, payload, expected, expect_failure=False):
| result = self._make_request(self.geocoder.reverse, **payload)
if (result is None):
if (not expect_failure):
self.fail('No result found')
else:
return
self._verify_request(result, **expected)
|
'Handles remote service errors.'
| @staticmethod
def _make_request(call, *args, **kwargs):
| try:
result = call(*args, **kwargs)
except exc.GeocoderQuotaExceeded:
raise unittest.SkipTest('Quota exceeded')
except exc.GeocoderTimedOut:
raise unittest.SkipTest('Service timed out')
except exc.GeocoderUnavailable:
raise unittest.SkipTest('Service unavailable')
return result
|
'Verifies that a a result matches the kwargs given.'
| def _verify_request(self, result, raw=EMPTY, latitude=EMPTY, longitude=EMPTY, address=EMPTY, osm_tag=EMPTY):
| item = (result[0] if isinstance(result, (tuple, list)) else result)
if (raw != EMPTY):
self.assertEqual(item.raw, raw)
if (latitude != EMPTY):
self.assertAlmostEqual(item.latitude, latitude, delta=self.delta)
if (longitude != EMPTY):
self.assertAlmostEqual(item.longitude, longitude, delta=self.delta)
if (address != EMPTY):
self.assertEqual(item.address, address)
if (osm_tag != EMPTY):
raw_osm_key = item.raw['properties']['osm_key']
if isinstance(osm_tag, string_compare):
self.assertEqual(raw_osm_key, osm_tag)
else:
self.assertIn(raw_osm_key, osm_tag)
|
'Photon.geocode'
| def test_geocode(self):
| self.geocode_run({'query': '14 rue pelisson villeurbanne'}, {'latitude': 45.7733963, 'longitude': 4.88612369})
|
'Photon.geocode osm_tag'
| def test_osm_tag(self):
| self.geocode_run({'query': 'Boulevard de Montreal'}, {'osm_tag': ['place', 'highway']})
|
'Photon.geocode unicode'
| def test_unicode_name(self):
| self.geocode_run({'query': u('\\u6545\\u5bab')}, {'latitude': 39.916, 'longitude': 116.39})
|
'Photon.reverse string'
| def test_reverse_string(self):
| self.reverse_run({'query': '45.7733105, 4.8869339'}, {'latitude': 45.7733105, 'longitude': 4.8869339})
|
'Photon.reverse Point'
| def test_reverse_point(self):
| self.reverse_run({'query': Point(45.7733105, 4.8869339)}, {'latitude': 45.7733105, 'longitude': 4.8869339})
|
'Photon.geocode using `language`'
| def test_geocode_language_parameter(self):
| result_geocode = self._make_request(self.geocoder.geocode, self.known_country_fr, language='it')
self.assertEqual(result_geocode.raw['properties']['country'], self.known_country_it)
|
'Photon.reverse using `language`'
| def test_reverse_language_parameter(self):
| result_reverse_it = self._make_request(self.geocoder.reverse, '45.7733105, 4.8869339', exactly_one=True, language='it')
self.assertEqual(result_reverse_it.raw['properties']['country'], self.known_country_it)
result_reverse_fr = self._make_request(self.geocoder.reverse, '45.7733105, 4.8869339', exactly_one=True, language='fr')
self.assertEqual(result_reverse_fr.raw['properties']['country'], self.known_country_fr)
|
'IGNFrance api_key without referer is ConfigurationError'
| def test_invalid_auth_1(self):
| with self.assertRaises(ConfigurationError):
IGNFrance(api_key='a')
|
'IGNFrance api_key, username, and referer is ConfigurationError'
| def test_invalid_auth_2(self):
| with self.assertRaises(ConfigurationError):
IGNFrance(api_key='a', username='b', referer='c')
|
'IGNFrance username without password is ConfgurationError'
| def test_invalid_auth_3(self):
| with self.assertRaises(ConfigurationError):
IGNFrance(api_key='a', username='b')
|
'IGNFrance.geocode invalid query_type'
| def test_invalid_query_type(self):
| with self.assertRaises(GeocoderQueryError):
self.geocoder.geocode('44109000EX0114', query_type='invalid')
|
'IGNFrance.geocode invalid CadastralParcel'
| def test_invalid_query_parcel(self):
| with self.assertRaises(GeocoderQueryError):
self.geocoder.geocode('incorrect length string', query_type='CadastralParcel')
|
'IGNFrance.geocode CadastralParcel'
| def test_geocode(self):
| self.geocode_run({'query': '44109000EX0114', 'query_type': 'CadastralParcel', 'exactly_one': True}, {'latitude': 47.222482, 'longitude': (-1.556303)})
|
'IGNFrance.geocode Address'
| def test_geocode_with_address(self):
| self.geocode_run({'query': 'Camp des Landes, 41200 VILLEFRANCHE-SUR-CHER', 'query_type': 'StreetAddress', 'exactly_one': True}, {'latitude': 47.293048, 'longitude': 1.718985, 'address': 'le camp des landes, 41200 Villefranche-sur-Cher'})
|
'IGNFrance.geocode with freeform and StreetAddress'
| def test_geocode_freeform(self):
| res = self._make_request(self.geocoder.geocode, query='8 rue G\xc3\xa9n\xc3\xa9ral Buat, Nantes', query_type='StreetAddress', is_freeform=True, exactly_one=True)
self.assertEqual(res.address, '8 r general buat , 44000 Nantes')
|
'IGNFrance.geocode with PositionOfInterest'
| def test_geocode_position_of_interest(self):
| res = self._make_request(self.geocoder.geocode, query='Chamb\xc3\xa9ry', query_type='PositionOfInterest', exactly_one=False)
self.assertEqual(res[0].address, '02000 Chambry')
self.assertEqual(res[1].address, '16420 Saint-Christophe')
|
'IGNFrance.geocode with filter by attribute'
| def test_geocode_filter_by_attribute(self):
| res = self._make_request(self.geocoder.geocode, query='Les Molettes', query_type='PositionOfInterest', maximum_responses=10, filtering='<Place type="Departement">38</Place>', exactly_one=False)
departements = [location.raw['departement'] for location in res]
unique = list(set(departements))
self.assertEqual(len(unique), 1)
self.assertEqual(unique[0], '38')
|
'IGNFrance.geocode using envelope'
| def test_geocode_filter_by_envelope(self):
| (lat_min, lng_min, lat_max, lng_max) = (45.0, 5, 46, 6.4)
spatial_filtering_envelope = '\n <gml:envelope>\n <gml:pos>{lat_min} {lng_min}</gml:pos>\n <gml:pos>{lat_max} {lng_max}</gml:pos>\n </gml:envelope>\n '.format(lat_min=lat_min, lng_min=lng_min, lat_max=lat_max, lng_max=lng_max)
res_spatial_filter = self._make_request(self.geocoder.geocode, 'Les Molettes', 'PositionOfInterest', maximum_responses=10, filtering=spatial_filtering_envelope, exactly_one=False)
departements_spatial = list(set([i.raw['departement'] for i in res_spatial_filter]))
res_no_spatial_filter = self._make_request(self.geocoder.geocode, 'Les Molettes', 'PositionOfInterest', maximum_responses=10, exactly_one=False)
departements_no_spatial = list(set([i.raw['departement'] for i in res_no_spatial_filter]))
self.assertGreater(len(departements_no_spatial), len(departements_spatial))
|
'IGNFrance.reverse simple'
| def test_reverse(self):
| res = self._make_request(self.geocoder.reverse, query='47.229554,-1.541519', exactly_one=True)
self.assertEqual(res.address, '3 av camille guerin, 44000 Nantes')
|
'IGNFrance.reverse with invalid reverse_geocode_preference'
| def test_reverse_invalid_preference(self):
| with self.assertRaises(GeocoderQueryError):
self.geocoder.reverse(query='47.229554,-1.541519', exactly_one=True, reverse_geocode_preference=['a'])
|
'IGNFrance.reverse preference'
| def test_reverse_preference(self):
| res = self._make_request(self.geocoder.reverse, query='47.229554,-1.541519', reverse_geocode_preference=['StreetAddress', 'PositionOfInterest'])
self.assertEqual(res[0].address, '3 av camille guerin, 44000 Nantes')
self.assertEqual(res[1].address, '5 av camille guerin, 44000 Nantes')
|
'IGNFrance.reverse by radius'
| def test_reverse_by_radius(self):
| spatial_filtering_radius = '\n <gml:CircleByCenterPoint>\n <gml:pos>{coord}</gml:pos>\n <gml:radius>{radius}</gml:radius>\n </gml:CircleByCenterPoint>\n '.format(coord='48.8033333 2.3241667', radius='50')
res_call_radius = self._make_request(self.geocoder.reverse, query='48.8033333,2.3241667', maximum_responses=10, filtering=spatial_filtering_radius)
res_call = self._make_request(self.geocoder.reverse, query='48.8033333,2.3241667', maximum_responses=10)
coordinates_couples_radius = set([((str(location.latitude) + ' ') + str(location.longitude)) for location in res_call_radius])
coordinates_couples = set([((str(location.latitude) + ' ') + str(location.longitude)) for location in res_call])
self.assertEqual(coordinates_couples_radius.issubset(coordinates_couples), True)
|
'DataBC.geocode'
| def test_geocode(self):
| res = self._make_request(self.geocoder.geocode, '135 North Pym Road, Parksville')
self.assertAlmostEqual(res.latitude, 49.321, delta=self.delta)
self.assertAlmostEqual(res.longitude, (-124.337), delta=self.delta)
|
'DataBC.geocode unicode'
| def test_unicode_name(self):
| res = self._make_request(self.geocoder.geocode, u('Barri\\u00e8re'))
self.assertAlmostEqual(res.latitude, 51.179, delta=self.delta)
self.assertAlmostEqual(res.longitude, (-120.123), delta=self.delta)
|
'DataBC.geocode with multiple results'
| def test_multiple_results(self):
| res = self._make_request(self.geocoder.geocode, '1st St', exactly_one=False)
self.assertGreater(len(res), 1)
|
'DataBC.geocode using optional params'
| def test_optional_params(self):
| res = self._make_request(self.geocoder.geocode, '5670 malibu terrace nanaimo bc', location_descriptor='accessPoint', set_back=100)
self.assertAlmostEqual(res.latitude, 49.2299, delta=self.delta)
self.assertAlmostEqual(res.longitude, (-124.0163), delta=self.delta)
|
'DataBC.geocode with bad query parameters'
| def test_query_error(self):
| with self.assertRaises(GeocoderQueryError):
res = self._make_request(self.geocoder.geocode, '1 Main St, Vancouver', location_descriptor='access_Point')
|
'What3Words.geocode - \'3 Words\' and \'OneWord\''
| def test_geocode(self):
| self.geocode_run({'query': u('piped.gains.jangle')}, {'latitude': 53.037611, 'longitude': 11.565012})
self.geocode_run({'query': u('*LibertyTech')}, {'latitude': 51.512573, 'longitude': (-0.144879)})
|
'What3Words.reverse - \'3 Words\''
| def test_reverse(self):
| result_reverse = self._make_request(self.geocoder.reverse, '53.037611,11.565012', lang='DE')
self.assertEqual(result_reverse.address, 'fortschrittliche.voll.schnitt')
|
'What3Words.geocode - \'3 Words\' unicode'
| def test_unicode_query(self):
| self.geocode_run({'query': u('\\u0070\\u0069\\u0070\\u0065\\u0064\\u002e\\u0067\\u0061\\u0069\\u006e\\u0073\\u002e\\u006a\\u0061\\u006e\\u0067\\u006c\\u0065')}, {'latitude': 53.037611, 'longitude': 11.565012})
self.geocode_run({'query': u('\\u002a\\u004c\\u0069\\u0062\\u0065\\u0072\\u0074\\u0079\\u0054\\u0065\\u0063\\u0068')}, {'latitude': 51.512573, 'longitude': (-0.144879)})
|
'What3Words.geocode result language'
| def test_result_language(self):
| result_geocode = self._make_request(self.geocoder.geocode, 'piped.gains.jangle', lang='DE')
self.assertEqual(result_geocode.address, 'fortschrittliche.voll.schnitt')
|
'What3Wors.check_query - \'OneWord\' and \'3 Words\' regex'
| def test_check_query(self):
| result_check_oneword_query = self.geocoder._check_query('*LibertyTech')
result_check_threeword_query = self.geocoder._check_query(u('\\u0066\\u0061\\u0068\\u0072\\u0070\\u0072\\u0065\\u0069\\u0073\\u002e\\u006c\\u00fc\\u0067\\u006e\\u0065\\u0072\\u002e\\u006b\\u0075\\u0074\\u0073\\u0063\\u0068\\u0065'))
self.assertTrue(result_check_oneword_query)
self.assertTrue(result_check_threeword_query)
|
'GeocoderDotUS Authorization header'
| def test_dot_us_auth(self):
| geocoder = GeocoderDotUS(username='username', password='password')
def _print_call_geocoder(query, timeout, raw):
'\n We want to abort at call time and just get the request object.\n '
raise Exception(query)
geocoder._call_geocoder = _print_call_geocoder
exc_raised = False
try:
geocoder.geocode('1 5th Ave NYC')
except Exception as err:
exc_raised = True
request = (err.message if (not py3k) else err.args[0])
self.assertEqual(request.get_header('Authorization'), 'Basic dXNlcm5hbWU6cGFzc3dvcmQ=')
self.assertTrue(exc_raised)
|
'GeocoderDotUS.geocode'
| def test_geocode(self):
| self.geocode_run({'query': '435 north michigan ave, chicago il 60611 usa'}, {'latitude': 41.89, 'longitude': (-87.624)})
|
'GeocoderDotUS.geocode unicode'
| def test_unicode_name(self):
| self.geocode_run({'query': u('\\u6545\\u5bab')}, {'latitude': 39.916, 'longitude': 116.39})
|
'GeocodeFarm.geocode'
| def test_geocode(self):
| self.geocode_run({'query': '435 north michigan ave, chicago il 60611 usa'}, {'latitude': 41.89, 'longitude': (-87.624)})
|
'GeocodeFarm.reverse string'
| def test_reverse_string(self):
| self.reverse_run({'query': '40.75376406311989,-73.98489005863667'}, {'latitude': 40.75376406311989, 'longitude': (-73.98489005863667)})
|
'GeocodeFarm.reverse Point'
| def test_reverse_point(self):
| self.reverse_run({'query': Point(40.75376406311989, (-73.98489005863667))}, {'latitude': 40.75376406311989, 'longitude': (-73.98489005863667)})
|
'GeocodeFarm authentication failure'
| def test_authentication_failure(self):
| self.geocoder = GeocodeFarm(api_key='invalid')
try:
with self.assertRaises(exc.GeocoderAuthenticationFailure):
address = '435 north michigan ave, chicago il 60611'
self.geocoder.geocode(address)
except exc.GeocoderTimedOut:
raise unittest.SkipTest('GeocodeFarm timed out')
|
'GeocodeFarm quota exceeded'
| def test_quota_exceeded(self):
| def mock_call_geocoder(*args, **kwargs):
'\n Mock API call to return bad response.\n '
return {'geocoding_results': {'STATUS': {'access': 'OVER_QUERY_LIMIT', 'status': 'FAILED, ACCESS_DENIED'}}}
self.geocoder._call_geocoder = types.MethodType(mock_call_geocoder, self.geocoder)
with self.assertRaises(exc.GeocoderQuotaExceeded):
self.geocoder.geocode('435 north michigan ave, chicago il 60611')
|
'GeocodeFarm unhandled error'
| def test_unhandled_api_error(self):
| def mock_call_geocoder(*args, **kwargs):
'\n Mock API call to return bad response.\n '
return {'geocoding_results': {'STATUS': {'access': 'BILL_PAST_DUE', 'status': 'FAILED, ACCESS_DENIED'}}}
self.geocoder._call_geocoder = types.MethodType(mock_call_geocoder, self.geocoder)
with self.assertRaises(exc.GeocoderServiceError):
self.geocoder.geocode('435 north michigan ave, chicago il 60611')
|
'Bing.geocode'
| def test_geocode(self):
| res = self._make_request(self.geocoder.geocode, '435 north michigan ave, chicago il 60611 usa')
if (res is None):
unittest.SkipTest('Bing sometimes returns no result')
else:
self.assertAlmostEqual(res.latitude, 41.89, delta=self.delta)
self.assertAlmostEqual(res.longitude, (-87.624), delta=self.delta)
|
'Bing.geocode unicode'
| def test_unicode_name(self):
| res = self._make_request(self.geocoder.geocode, u('\\u6545\\u5bab'))
if (res is None):
unittest.SkipTest('Bing sometimes returns no result')
else:
self.assertAlmostEqual(res.latitude, 39.916, delta=self.delta)
self.assertAlmostEqual(res.longitude, 116.39, delta=self.delta)
|
'Bing.reverse using point'
| def test_reverse_point(self):
| res = self._make_request(self.geocoder.reverse, Point(40.753898, (-73.985071)))
if (res is None):
unittest.SkipTest('Bing sometimes returns no result')
else:
self.assertAlmostEqual(res.latitude, 40.753, delta=self.delta)
self.assertAlmostEqual(res.longitude, (-73.984), delta=self.delta)
|
'Bing.geocode using `user_location`'
| def test_user_location(self):
| pensylvania = '20 Main St, Walnutport, PA 18088, United States'
colorado = '20 Main St, Broomfield, CO 80020, United States'
pennsylvania_bias = (40.922351, (-75.096562))
colorado_bias = (39.914231, (-105.070104))
for each in ((pensylvania, pennsylvania_bias), (colorado, colorado_bias)):
res = self._make_request(self.geocoder.geocode, '20 Main Street', user_location=Point(each[1]))
if (res is None):
unittest.SkipTest('Bing sometimes returns no result')
else:
self.assertEqual(res[0], each[0])
|
'Bing.geocode using optional params'
| def test_optional_params(self):
| address_string = 'Badeniho 1, Prague, Czech Republic'
res = self._make_request(self.geocoder.geocode, query=address_string, culture='cs', include_neighborhood=True, include_country_code=True)
if (res is None):
unittest.SkipTest('Bing sometimes returns no result')
else:
address = res.raw['address']
self.assertEqual(address['neighborhood'], 'Praha 6')
self.assertEqual(address['countryRegionIso2'], 'CZ')
|
'Bing.geocode using structured query'
| def test_structured_query(self):
| address_dict = {'postalCode': '80020', 'countryRegion': 'United States'}
res = self._make_request(self.geocoder.geocode, query=address_dict)
if (res is None):
unittest.SkipTest('Bing sometimes returns no result')
else:
address = res.raw['address']
self.assertEqual(address['locality'], 'Broomfield')
|
'Nominatim.geocode'
| def test_geocode(self):
| self.geocode_run({'query': '435 north michigan ave, chicago il 60611 usa'}, {'latitude': 41.89, 'longitude': (-87.624)})
|
'Nominatim.geocode unicode'
| def test_unicode_name(self):
| self.geocode_run({'query': u('\\u6545\\u5bab')}, {'latitude': 39.916, 'longitude': 116.39})
|
'Nominatim.reverse string'
| def test_reverse_string(self):
| self.reverse_run({'query': '40.75376406311989, -73.98489005863667'}, {'latitude': 40.75376406311989, 'longitude': (-73.98489005863667)})
|
'Nominatim.reverse Point'
| def test_reverse_point(self):
| self.reverse_run({'query': Point(40.75376406311989, (-73.98489005863667))}, {'latitude': 40.75376406311989, 'longitude': (-73.98489005863667)})
|
'Nominatim.geocode using `addressdetails`'
| def test_city_district_with_dict_query(self):
| geocoder = Nominatim(country_bias='DE')
query = {'postalcode': 10117}
result = self._make_request(geocoder.geocode, query, addressdetails=True)
self.assertEqual(result.raw['address']['city_district'], 'Mitte')
|
'Nominatim.geocode using `language`'
| def test_geocode_language_parameter(self):
| input = 'Mohrenstrasse Berlin'
result_geocode = self._make_request(self.geocoder.geocode, input, addressdetails=True, language='de')
self.assertEqual(result_geocode.raw['address']['country'], 'Deutschland')
result_geocode = self._make_request(self.geocoder.geocode, input, addressdetails=True, language='en')
self.assertEqual(result_geocode.raw['address']['country'], 'Germany')
|
'Nominatim.reverse using `language`'
| def test_reverse_language_parameter(self):
| result_reverse_de = self._make_request(self.geocoder.reverse, '52.51693903613385, 13.3859332733135', exactly_one=True, language='de')
self.assertEqual(result_reverse_de.raw['address']['country'], 'Deutschland')
result_reverse_en = self._make_request(self.geocoder.reverse, '52.51693903613385, 13.3859332733135', exactly_one=True, language='en')
self.assertTrue(('Germany' in result_reverse_en.raw['address']['country']))
|
'Nominatim.geocode with full geometry (response in WKT format)'
| def test_geocode_geometry_wkt(self):
| input = 'Halensee,Berlin'
result_geocode = self._make_request(self.geocoder.geocode, input, geometry='WKT')
self.assertEqual(result_geocode.raw['geotext'].startswith('POLYGON(('), True)
|
'Nominatim.geocode with full geometry (response in svg format)'
| def test_geocode_geometry_svg(self):
| input = 'Halensee,Berlin'
result_geocode = self._make_request(self.geocoder.geocode, input, geometry='svg')
self.assertEqual(result_geocode.raw['svg'].startswith('M 13.'), True)
|
'Nominatim.geocode with full geometry (response in kml format)'
| def test_geocode_geometry_kml(self):
| input = 'Halensee,Berlin'
result_geocode = self._make_request(self.geocoder.geocode, input, geometry='kml')
self.assertEqual(result_geocode.raw['geokml'].startswith('<Polygon>'), True)
|
'Nominatim.geocode with full geometry (response in geojson format)'
| def test_geocode_geometry_geojson(self):
| input = 'Halensee,Berlin'
result_geocode = self._make_request(self.geocoder.geocode, input, geometry='geojson')
self.assertEqual(result_geocode.raw['geojson'].get('type'), 'Polygon')
|
'GoogleV3 raises configuration errors on invalid auth params'
| def test_configuration_error(self):
| with self.assertRaises(exc.ConfigurationError):
GoogleV3(client_id='a')
with self.assertRaises(exc.ConfigurationError):
GoogleV3(secret_key='a')
|
'GoogleV3 raises correctly on Google-specific API status flags'
| def test_check_status(self):
| self.assertEqual(self.geocoder._check_status('ZERO_RESULTS'), None)
with self.assertRaises(exc.GeocoderQuotaExceeded):
self.geocoder._check_status('OVER_QUERY_LIMIT')
with self.assertRaises(exc.GeocoderQueryError):
self.geocoder._check_status('REQUEST_DENIED')
with self.assertRaises(exc.GeocoderQueryError):
self.geocoder._check_status('INVALID_REQUEST')
with self.assertRaises(exc.GeocoderQueryError):
self.geocoder._check_status('_')
|
'GoogleV3._get_signed_url'
| def test_get_signed_url(self):
| geocoder = GoogleV3(client_id='my_client_id', secret_key=base64.urlsafe_b64encode('my_secret_key'.encode('utf8')))
self.assertTrue(geocoder.premier)
self.assertTrue((geocoder._get_signed_url({'address': '1 5th Ave New York, NY'}) in ('https://maps.googleapis.com/maps/api/geocode/json?address=1+5th+Ave+New+York%2C+NY&client=my_client_id&signature=Z_1zMBa3Xu0W4VmQfaBR8OQMnDM=', 'https://maps.googleapis.com/maps/api/geocode/json?client=my_client_id&address=1+5th+Ave+New+York%2C+NY&signature=D3PL0cZJrJYfveGSNoGqrrMsz0M=')))
|
'GoogleV3._get_signed_url'
| def test_get_signed_url_with_channel(self):
| geocoder = GoogleV3(client_id='my_client_id', secret_key=base64.urlsafe_b64encode('my_secret_key'.encode('utf8')), channel='my_channel')
signed_url = geocoder._get_signed_url({'address': '1 5th Ave New York, NY'})
params = parse_qs(urlparse(signed_url).query)
self.assertTrue(('channel' in params))
self.assertTrue(('signature' in params))
self.assertTrue(('client' in params))
|
'GoogleV3._format_components_param'
| def test_format_components_param(self):
| f = GoogleV3._format_components_param
self.assertEqual(f({}), '')
self.assertEqual(f({'country': 'FR'}), 'country:FR')
output = f({'administrative_area': 'CA', 'country': 'FR'})
self.assertTrue((output in ('administrative_area:CA|country:FR', 'country:FR|administrative_area:CA')), output)
with self.assertRaises(AttributeError):
f(None)
with self.assertRaises(AttributeError):
f([])
with self.assertRaises(AttributeError):
f('administrative_area:CA|country:FR')
|
'GoogleV3.geocode'
| def test_geocode(self):
| self.geocode_run({'query': '435 north michigan ave, chicago il 60611 usa'}, {'latitude': 41.89, 'longitude': (-87.624)})
|
'GoogleV3.geocode unicode'
| def test_unicode_name(self):
| self.geocode_run({'query': u('\\u6545\\u5bab')}, {'latitude': 39.916, 'longitude': 116.39})
|
'GoogleV3.geocode returns None on conflicting components'
| def test_geocode_components(self):
| self.geocode_run({'query': 'santa cruz', 'components': {'administrative_area': 'CA', 'country': 'FR'}}, {}, expect_failure=True)
|
'GoogleV3.geocode with components'
| def test_components(self):
| self.geocode_run({'query': 'santa cruz', 'components': {'country': 'ES'}}, {'latitude': 28.4636296, 'longitude': (-16.2518467)})
|
'GoogleV3.reverse string'
| def test_reverse_string(self):
| self.reverse_run({'query': '40.75376406311989, -73.98489005863667'}, {'latitude': 40.75376406311989, 'longitude': (-73.98489005863667)})
|
'GoogleV3.reverse Point'
| def test_reverse_point(self):
| self.reverse_run({'query': self.new_york_point}, {'latitude': 40.75376406311989, 'longitude': (-73.98489005863667)})
|
'GoogleV3.geocode returns None for no result'
| def test_zero_results(self):
| self.assertRaises(exc.GeocoderQueryError, self._make_request, self.geocoder.geocode, '')
|
'GoogleV3.timezone returns pytz object from datetime'
| def test_timezone_datetime(self):
| tz = self._make_request(self.geocoder.timezone, self.new_york_point, datetime.utcfromtimestamp(0))
self.assertEqual(tz, self.america_new_york)
|
'GoogleV3.timezone returns pytz object from epoch integer'
| def test_timezone_integer(self):
| tz = self._make_request(self.geocoder.timezone, self.new_york_point, 0)
self.assertEqual(tz, self.america_new_york)
|
'GoogleV3.timezone defaults `at_time`'
| def test_timezone_no_date(self):
| tz = self._make_request(self.geocoder.timezone, self.new_york_point)
self.assertEqual(tz, self.america_new_york)
|
'GoogleV3.timezone invalid `at_time`'
| def test_timezone_invalid_at_time(self):
| with self.assertRaises(exc.GeocoderQueryError):
self.geocoder.timezone(self.new_york_point, 'eek')
|
'GoogleV3.geocode check bounds restriction'
| def test_geocode_bounds(self):
| self.geocode_run({'query': '221b Baker St', 'bounds': [50, (-2), 55, 2]}, {'latitude': 51.52, 'longitude': (-0.15)})
|
'GoogleV3.geocode bounds must be 4-length iterable'
| def test_geocode_bounds_invalid(self):
| with self.assertRaises(exc.GeocoderQueryError):
self.geocode_run({'query': '221b Baker St', 'bounds': [50, (-2), 55]}, {'latitude': 51.52, 'longitude': (-0.15)})
|
'YahooPlaceFinder.geocode'
| def test_geocode(self):
| self.geocode_run({'query': 'nyc'}, {'latitude': 40.71455, 'longitude': (-74.00712)})
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.