Pure Python implementation of clients for Mapbox services

server/lib/python/cartodb_services/test/test_mapboxgeocoder.py

@@ -0,0 +1,24 @@
+import unittest
+from cartodb_services.mapbox import MapboxGeocoder
+from cartodb_services.mapbox import ServiceException
+
+INVALID_TOKEN = 'invalid_token'
+VALID_ADDRESS = 'Calle Siempreviva 3, Valladolid'
+WELL_KNOWN_LONGITUDE = -4.730947
+WELL_KNOWN_LATITUDE = 41.668654
+
+
+class MapboxGeocoderTestCase(unittest.TestCase):
+    def setUp(self):
+        self.geocoder = MapboxGeocoder()
+
+    def test_invalid_token(self):
+        invalid_geocoder = MapboxGeocoder(token=INVALID_TOKEN)
+        with self.assertRaises(ServiceException):
+            invalid_geocoder.geocode(VALID_ADDRESS)
+
+    def test_valid_request(self):
+        place = self.geocoder.geocode(VALID_ADDRESS)
+
+        self.assertEqual(place[0], WELL_KNOWN_LONGITUDE)
+        self.assertEqual(place[1], WELL_KNOWN_LATITUDE)

server/lib/python/cartodb_services/test/test_mapboxisoline.py

@@ -0,0 +1,36 @@
+import unittest
+from cartodb_services.mapbox.isolines import MapboxIsolines
+from cartodb_services.mapbox.matrix_client import DEFAULT_PROFILE
+from cartodb_services.mapbox.matrix_client import MapboxMatrixClient
+from cartodb_services.mapbox.routing import MapboxRouting
+from cartodb_services.tools import Coordinate
+from cartodb_services.tools.coordinates import (validate_coordinates,
+                                                marshall_coordinates)
+
+VALID_ORIGIN = Coordinate(-73.989, 40.733)
+
+
+class MapboxIsolinesTestCase(unittest.TestCase):
+
+    def setUp(self):
+        matrix_client = MapboxMatrixClient()
+        routing_client = MapboxRouting()
+        self.mapbox_isolines = MapboxIsolines(matrix_client, routing_client)
+
+    def test_calculate_isochrone(self):
+        time_range = 10 * 60  # 10 minutes
+        solution = self.mapbox_isolines.calculate_isochrone(
+            origin=VALID_ORIGIN,
+            profile=DEFAULT_PROFILE,
+            time_range=time_range)
+
+        assert solution
+
+    def test_calculate_isodistance(self):
+        distance_range = 10000
+        solution = self.mapbox_isolines.calculate_isodistance(
+            origin=VALID_ORIGIN,
+            profile=DEFAULT_PROFILE,
+            distance_range=distance_range)
+
+        assert solution

server/lib/python/cartodb_services/test/test_mapboxmatrix.py

@@ -0,0 +1,54 @@
+import unittest
+from cartodb_services.mapbox import MapboxMatrixClient
+from cartodb_services.mapbox.matrix_client import DEFAULT_PROFILE
+from cartodb_services.mapbox import ServiceException
+from cartodb_services.tools import Coordinate
+
+INVALID_TOKEN = 'invalid_token'
+VALID_ORIGIN = Coordinate(-73.989, 40.733)
+VALID_TARGET = Coordinate(-74, 40.733)
+VALID_COORDINATES = [VALID_ORIGIN] + [VALID_TARGET]
+NUM_COORDINATES_MAX = 25
+INVALID_COORDINATES_EMPTY = []
+INVALID_COORDINATES_MIN = [VALID_ORIGIN]
+INVALID_COORDINATES_MAX = [VALID_ORIGIN] + \
+                          [VALID_TARGET
+                           for x in range(0, NUM_COORDINATES_MAX + 1)]
+VALID_PROFILE = DEFAULT_PROFILE
+INVALID_PROFILE = 'invalid_profile'
+
+
+class MapboxMatrixTestCase(unittest.TestCase):
+    def setUp(self):
+        self.matrix_client = MapboxMatrixClient()
+
+    def test_invalid_profile(self):
+        with self.assertRaises(ValueError):
+            self.matrix_client.matrix(VALID_COORDINATES,
+                                      INVALID_PROFILE)
+
+    def test_invalid_coordinates_empty(self):
+        with self.assertRaises(ValueError):
+            self.matrix_client.matrix(INVALID_COORDINATES_EMPTY,
+                                      VALID_PROFILE)
+
+    def test_invalid_coordinates_max(self):
+        with self.assertRaises(ValueError):
+            self.matrix_client.matrix(INVALID_COORDINATES_MAX,
+                                      VALID_PROFILE)
+
+    def test_invalid_coordinates_min(self):
+        with self.assertRaises(ValueError):
+            self.matrix_client.matrix(INVALID_COORDINATES_MIN,
+                                      VALID_PROFILE)
+
+    def test_invalid_token(self):
+        invalid_matrix = MapboxMatrixClient(token=INVALID_TOKEN)
+        with self.assertRaises(ServiceException):
+            invalid_matrix.matrix(VALID_COORDINATES,
+                                  VALID_PROFILE)
+
+    def test_valid_request(self):
+        distance_matrix = self.matrix_client.matrix(VALID_COORDINATES,
+                                                    VALID_PROFILE)
+        assert distance_matrix

server/lib/python/cartodb_services/test/test_mapboxrouting.py

@@ -0,0 +1,61 @@
+import unittest
+from cartodb_services.mapbox import MapboxRouting
+from cartodb_services.mapbox.routing import DEFAULT_PROFILE
+from cartodb_services.mapbox import ServiceException
+from cartodb_services.tools import Coordinate
+
+INVALID_TOKEN = 'invalid_token'
+VALID_WAYPOINTS = [Coordinate(-73.989, 40.733), Coordinate(-74, 40.733)]
+NUM_WAYPOINTS_MAX = 25
+INVALID_WAYPOINTS_EMPTY = []
+INVALID_WAYPOINTS_MIN = [Coordinate(-73.989, 40.733)]
+INVALID_WAYPOINTS_MAX = [Coordinate(-73.989, 40.733)
+                         for x in range(0, NUM_WAYPOINTS_MAX + 2)]
+VALID_PROFILE = DEFAULT_PROFILE
+INVALID_PROFILE = 'invalid_profile'
+
+WELL_KNOWN_SHAPE = [(40.73312, -73.98891), (40.73353, -73.98987),
+                    (40.73398, -73.99095), (40.73453, -73.99227),
+                    (40.73531, -73.99412), (40.73467, -73.99459),
+                    (40.73442, -73.99477), (40.73435, -73.99482),
+                    (40.73403, -73.99505), (40.73344, -73.99549),
+                    (40.73286, -73.9959), (40.73226, -73.99635),
+                    (40.73186, -73.99664), (40.73147, -73.99693),
+                    (40.73141, -73.99698), (40.73147, -73.99707),
+                    (40.73219, -73.99856), (40.73222, -73.99861),
+                    (40.73293, -74.00007), (40.733, -74.00001)]
+WELL_KNOWN_LENGTH = 1317.9
+
+
+class MapboxRoutingTestCase(unittest.TestCase):
+    def setUp(self):
+        self.routing = MapboxRouting()
+
+    def test_invalid_profile(self):
+        with self.assertRaises(ValueError):
+            self.routing.directions(VALID_WAYPOINTS, INVALID_PROFILE)
+
+    def test_invalid_waypoints_empty(self):
+        with self.assertRaises(ValueError):
+            self.routing.directions(INVALID_WAYPOINTS_EMPTY, VALID_PROFILE)
+
+    def test_invalid_waypoints_min(self):
+        with self.assertRaises(ValueError):
+            self.routing.directions(INVALID_WAYPOINTS_MIN, VALID_PROFILE)
+
+    def test_invalid_waypoints_max(self):
+        with self.assertRaises(ValueError):
+            self.routing.directions(INVALID_WAYPOINTS_MAX, VALID_PROFILE)
+
+    def test_invalid_token(self):
+        invalid_routing = MapboxRouting(token=INVALID_TOKEN)
+        with self.assertRaises(ServiceException):
+            invalid_routing.directions(VALID_WAYPOINTS,
+                                       VALID_PROFILE)
+
+    def test_valid_request(self):
+        route = self.routing.directions(VALID_WAYPOINTS, VALID_PROFILE)
+
+        self.assertEqual(route.shape, WELL_KNOWN_SHAPE)
+        self.assertEqual(route.length, WELL_KNOWN_LENGTH)
+        assert route.duration  # The duration may change between executions