Tests: git rid of raw _make_request usages

geopy · Jun 11, 2018 · ca6c2be · ca6c2be
1 parent 4e2bf9e
commit ca6c2be
Show file tree

Hide file tree

Showing 6 changed files with 120 additions and 142 deletions.
diff --git a/test/geocoders/databc.py b/test/geocoders/databc.py
@@ -20,57 +20,50 @@ def test_geocode(self):
         """
         DataBC.geocode
         """
-        res = self._make_request(
-            self.geocoder.geocode,
-            "135 North Pym Road, Parksville"
+        self.geocode_run(
+            {"query": "135 North Pym Road, Parksville"},
+            {"latitude": 49.321, "longitude": -124.337},
         )
-        self.assertAlmostEqual(res.latitude, 49.321, delta=self.delta)
-        self.assertAlmostEqual(res.longitude, -124.337, delta=self.delta)
 
     def test_unicode_name(self):
         """
         DataBC.geocode unicode
         """
-        res = self._make_request(
-            self.geocoder.geocode,
-            u("Barri\u00e8re"),
+        self.geocode_run(
+            {"query": u("Barri\u00e8re")},
+            {"latitude": 51.179, "longitude": -120.123},
         )
-        self.assertAlmostEqual(res.latitude, 51.179, delta=self.delta)
-        self.assertAlmostEqual(res.longitude, -120.123, delta=self.delta)
 
     def test_multiple_results(self):
         """
         DataBC.geocode with multiple results
         """
-        res = self._make_request(
-            self.geocoder.geocode,
-            "1st St",
-            exactly_one=False
+        res = self.geocode_run(
+            {"query": "1st St", "exactly_one": False},
+            {},
         )
-
         self.assertGreater(len(res), 1)
 
     def test_optional_params(self):
         """
         DataBC.geocode using optional params
         """
 
-        res = self._make_request(
-            self.geocoder.geocode,
-            "5670 malibu terrace nanaimo bc",
-            location_descriptor="accessPoint",
-            set_back=100
+        self.geocode_run(
+            {"query": "5670 malibu terrace nanaimo bc",
+             "location_descriptor": "accessPoint",
+             "set_back": 100},
+            {"latitude": 49.2299, "longitude": -124.0163},
         )
-        self.assertAlmostEqual(res.latitude, 49.2299, delta=self.delta)
-        self.assertAlmostEqual(res.longitude, -124.0163, delta=self.delta)
 
     def test_query_error(self):
         """
         DataBC.geocode with bad query parameters
         """
         with self.assertRaises(GeocoderQueryError):
-            self._make_request(
-                self.geocoder.geocode,
-                "1 Main St, Vancouver",
-                location_descriptor="access_Point",
+            self.geocode_run(
+                {"query": "1 Main St, Vancouver",
+                 "location_descriptor": "access_Point"},
+                {},
+                expect_failure=True,
             )
diff --git a/test/geocoders/geocodefarm.py b/test/geocoders/geocodefarm.py
@@ -1,4 +1,3 @@
-import unittest
 from mock import patch
 
 from geopy import exc
@@ -66,12 +65,12 @@ def test_authentication_failure(self):
         GeocodeFarm authentication failure
         """
         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")
+        with self.assertRaises(exc.GeocoderAuthenticationFailure):
+            self.geocode_run(
+                {"query": '435 north michigan ave, chicago il 60611'},
+                {},
+                expect_failure=True,
+            )
 
     def test_quota_exceeded(self):
         """

diff --git a/test/geocoders/googlev3.py b/test/geocoders/googlev3.py
@@ -17,6 +17,10 @@ def setUpClass(cls):
         cls.new_york_point = Point(40.75376406311989, -73.98489005863667)
         cls.america_new_york = timezone("America/New_York")
 
+    def timezone_run(self, payload, expected):
+        tz = self._make_request(self.geocoder.timezone, **payload)
+        self.assertEqual(tz, expected)
+
     def test_user_agent_custom(self):
         geocoder = GoogleV3(
             user_agent='my_user_agent/1.0'
@@ -192,39 +196,39 @@ def test_zero_results(self):
         GoogleV3.geocode returns None for no result
         """
         with self.assertRaises(exc.GeocoderQueryError):
-            self._make_request(self.geocoder.geocode, '')
+            self.geocode_run(
+                {"query": ''},
+                {},
+                expect_failure=True,
+            )
 
     def test_timezone_datetime(self):
         """
         GoogleV3.timezone returns pytz object from datetime
         """
-        tz = self._make_request(
-            self.geocoder.timezone,
-            self.new_york_point,
-            datetime.utcfromtimestamp(0)
+        self.timezone_run(
+            {"location": self.new_york_point,
+             "at_time": datetime.utcfromtimestamp(0)},
+            self.america_new_york,
         )
-        self.assertEqual(tz, self.america_new_york)
 
     def test_timezone_integer(self):
         """
         GoogleV3.timezone returns pytz object from epoch integer
         """
-        tz = self._make_request(
-            self.geocoder.timezone,
-            self.new_york_point,
-            0
+        self.timezone_run(
+            {"location": self.new_york_point, "at_time": 0},
+            self.america_new_york,
         )
-        self.assertEqual(tz, self.america_new_york)
 
     def test_timezone_no_date(self):
         """
         GoogleV3.timezone defaults `at_time`
         """
-        tz = self._make_request(
-            self.geocoder.timezone,
-            self.new_york_point,
+        self.timezone_run(
+            {"location": self.new_york_point},
+            self.america_new_york,
         )
-        self.assertEqual(tz, self.america_new_york)
 
     def test_timezone_invalid_at_time(self):
         """

diff --git a/test/geocoders/ignfrance.py b/test/geocoders/ignfrance.py
@@ -110,28 +110,25 @@ def test_geocode_freeform(self):
         """
         IGNFrance.geocode with freeform and StreetAddress
         """
-        res = self._make_request(
-            self.geocoder.geocode,
-            query="8 rue Général Buat, Nantes",
-            query_type="StreetAddress",
-            is_freeform=True,
-            exactly_one=True
-        )
-        self.assertEqual(
-            res.address,
-            "8 r general buat , 44000 Nantes"
+        self.geocode_run(
+            {"query": "8 rue Général Buat, Nantes",
+             "query_type": "StreetAddress",
+             "is_freeform": True,
+             "exactly_one": True},
+            {"address": "8 r general buat , 44000 Nantes"},
         )
 
     def test_geocode_position_of_interest(self):
         """
         IGNFrance.geocode with PositionOfInterest
         """
-        res = self._make_request(
-            self.geocoder.geocode,
-            query="Chambéry",
-            query_type="PositionOfInterest",
-            exactly_one=False
+        res = self.geocode_run(
+            {"query": "Chambéry",
+             "query_type": "PositionOfInterest",
+             "exactly_one": False},
+            {},
         )
+
         self.assertEqual(
             res[0].address,
             "02000 Chambry"
@@ -145,26 +142,20 @@ def test_geocode_filter_by_attribute(self):
         """
         IGNFrance.geocode with filter by attribute
         """
-        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
+        res = self.geocode_run(
+            {"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"
-        )
+        self.assertEqual(len(unique), 1)
+        self.assertEqual(unique[0], "38")
 
     def test_geocode_filter_by_envelope(self):
         """
@@ -184,25 +175,25 @@ def test_geocode_filter_by_envelope(self):
             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
+        res_spatial_filter = self.geocode_run(
+            {"query": 'Les Molettes',
+             "query_type": 'PositionOfInterest',
+             "maximum_responses": 10,
+             "filtering": spatial_filtering_envelope,
+             "exactly_one": False},
+            {},
         )
 
         departements_spatial = list(
             {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
+        res_no_spatial_filter = self.geocode_run(
+            {"query": 'Les Molettes',
+             "query_type": 'PositionOfInterest',
+             "maximum_responses": 10,
+             "exactly_one": False},
+            {},
         )
 
         departements_no_spatial = list(
@@ -221,10 +212,10 @@ def test_reverse(self):
         """
         IGNFrance.reverse simple
         """
-        res = self._make_request(
-            self.geocoder.reverse,
-            query='47.229554,-1.541519',
-            exactly_one=True
+        res = self.reverse_run(
+            {"query": '47.229554,-1.541519',
+             "exactly_one": True},
+            {},
         )
         self.assertEqual(
             res.address,
@@ -246,11 +237,11 @@ def test_reverse_preference(self):
         """
         IGNFrance.reverse preference
         """
-        res = self._make_request(
-            self.geocoder.reverse,
-            query='47.229554,-1.541519',
-            exactly_one=False,
-            reverse_geocode_preference=['StreetAddress', 'PositionOfInterest']
+        res = self.reverse_run(
+            {"query": '47.229554,-1.541519',
+             "exactly_one": False,
+             "reverse_geocode_preference": ['StreetAddress', 'PositionOfInterest']},
+            {},
         )
         self.assertEqual(
             res[0].address,
@@ -272,18 +263,19 @@ def test_reverse_by_radius(self):
         </gml:CircleByCenterPoint>
         """.format(coord='48.8033333 2.3241667', radius='50')
 
-        res_call_radius = self._make_request(
-            self.geocoder.reverse,
-            query='48.8033333,2.3241667',
-            exactly_one=False,
-            maximum_responses=10,
-            filtering=spatial_filtering_radius)
-
-        res_call = self._make_request(
-            self.geocoder.reverse,
-            query='48.8033333,2.3241667',
-            exactly_one=False,
-            maximum_responses=10
+        res_call_radius = self.reverse_run(
+            {"query": '48.8033333,2.3241667',
+             "exactly_one": False,
+             "maximum_responses": 10,
+             "filtering": spatial_filtering_radius},
+            {},
+        )
+
+        res_call = self.reverse_run(
+            {"query": '48.8033333,2.3241667',
+             "exactly_one": False,
+             "maximum_responses": 10},
+            {},
         )
 
         coordinates_couples_radius = set([

diff --git a/test/geocoders/photon.py b/test/geocoders/photon.py
@@ -76,10 +76,9 @@ def test_geocode_language_parameter(self):
         """
         Photon.geocode using `language`
         """
-        result_geocode = self._make_request(
-            self.geocoder.geocode,
-            self.known_country_fr,
-            language="it",
+        result_geocode = self.geocode_run(
+            {"query": self.known_country_fr, "language": "it"},
+            {},
         )
         self.assertEqual(
             result_geocode.raw['properties']['country'],
@@ -90,22 +89,23 @@ def test_reverse_language_parameter(self):
         """
         Photon.reverse using `language`
         """
-        result_reverse_it = self._make_request(
-            self.geocoder.reverse,
-            "45.7733105, 4.8869339",
-            exactly_one=True,
-            language="it",
+
+        result_reverse_it = self.reverse_run(
+            {"query": "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"
+        result_reverse_fr = self.reverse_run(
+            {"query": "45.7733105, 4.8869339",
+             "exactly_one": True,
+             "language": "fr"},
+            {},
         )
         self.assertEqual(
             result_reverse_fr.raw['properties']['country'],