def test_routes_dataframe_closest_stops_returns_closest_stop(self):
handler = DatabaseHandler('unit_test_db.sqlite3')
handler.initialize_db()
handler.add_address(MapLocation(latitude=1, longitude=1, id=1))
handler.add_stop(MapLocation(latitude=2, longitude=2, id=2))
handler.add_stop(MapLocation(latitude=3, longitude=3, id=3))
handler.add_route(address=1, stop=2, distance=100, time=100)
handler.add_route(address=1, stop=3, distance=50, time=50)
df = handler.routes_dataframe_closest_stops()
self.assertEqual(1, df.shape[0], "should be 1 output row")
self.assertEqual(1, df.ix[0, 'address_latitude'],
'address should have latitude of 1')
self.assertEqual(1, df.ix[0, 'address_longitude'],
'address should have longitude of 1')
self.assertEqual(
3, df.ix[0, 'stop_latitude'],
'the stop with latitude of 3 should have been '
'returned since it had the smallest distance')
self.assertEqual(
3, df.ix[0, 'stop_longitude'],
'the stop with longitude of 3 should have been '
'returned since it had the smallest distance')
self.assertEqual(
50, df.ix[0, 'distance'],
"the route with the lowest distance should be"
"returned in the output dataframe")
self.assertEqual(
50, df.ix[0, 'time'],
"the route the with lowest distance's time should be"
"returned in the output dataframe")
def test_get_address_without_route_returns_with_correct_id(self):
handler = DatabaseHandler('unit_test_db.sqlite3')
handler.add_address(MapLocation(latitude=2, longitude=2, id=222))
address_generator = handler.get_address_generator()
self.assertEqual(MapLocation(latitude=2, longitude=2, id=222),
address_generator.next(),
"MapLocation should return correct id")
def test_get_distance_from_api_calls_make_api_call(self):
self.wrapper._construct_request_string = Mock(return_value='request')
self.wrapper._call_api = Mock(return_value=[])
self.wrapper._parse_response = Mock()
self.wrapper.get_distance_from_api(MapLocation(), MapLocation())
self.wrapper._call_api.assert_called_once_with('request')
def test_otherwise_identical_MapLocations_with_different_ids_unequal(self):
a = MapLocation(latitude=10, longitude=10, id=3)
b = MapLocation(latitude=10, longitude=10, id=50)
self.assertTrue(
a != b, "MapLocations with equal latitudes and "
"longitudes, but different id's should not be "
"equal")
def test_get_address_without_route_returns_address_when_routes_empty(self):
handler = DatabaseHandler('unit_test_db.sqlite3')
handler.add_address(
location=MapLocation(latitude=5, longitude=6, id=1))
address_generator = handler.get_address_generator()
self.assertEqual(MapLocation(latitude=5, longitude=6, id=1),
address_generator.next(),
"Only MapLocation in addresses was not returned")
def test_add_route_adds_route(self):
handler = DatabaseHandler('unit_test_db.sqlite3')
handler.add_address(location=MapLocation(latitude=5, longitude=5))
handler.add_stop(location=MapLocation(latitude=2, longitude=2))
handler.add_route(address=1, stop=1, distance=10, time=20)
c = handler.conn.cursor()
c.execute("SELECT * FROM routes")
self.assertEqual((1, 1, 1, 10, 20), c.fetchone())
def test_get_distance_from_api_parses_response(self):
self.wrapper._construct_request_string = Mock()
self.wrapper._call_api = Mock(return_value="json")
self.wrapper._parse_response = Mock(return_value=[5, 10])
dist = self.wrapper.get_distance_from_api(MapLocation(), MapLocation())
self.wrapper._parse_response.assert_called_once_with("json")
self.assertEqual([5, 10], dist)
def test_get_all_stops_returns_list_of_MapLocations(self, mock_init_db):
handler = DatabaseHandler('unit_test_db.sqlite3')
handler._add_stops_table()
handler.add_stop(MapLocation(latitude=5, longitude=6))
handler.add_stop(MapLocation(latitude=3, longitude=-5))
stops = handler.get_all_stops()
self.assertEqual((5, 6), (stops[0].latitude, stops[0].longitude))
self.assertEqual((3, -5), (stops[1].latitude, stops[1].longitude))
def test_construct_request_string_produces_correct_output(self):
origin = MapLocation(latitude=50.032, longitude=40.54453)
destination = MapLocation(latitude=51.0345, longitude=41.2314)
self.wrapper.key = 'api_key'
self.assertEqual(
'https://api.mapbox.com/v4/directions/mapbox.walking/'
'40.54453,50.032;41.2314,51.0345.json?alternatives='
'false&instructions=text&geometry=false&steps=false&&'
'access_token=api_key',
self.wrapper._construct_request_string(origin, destination),
'incorrect request string returned')
def test_get_distance_from_api_passes_in_mode_string(self):
self.wrapper._construct_request_string = Mock(return_value='request')
self.wrapper._call_api = Mock(return_value=[])
self.wrapper._parse_response = Mock()
origin = MapLocation(1, 1, 1)
destination = MapLocation(2, 2, 2)
self.wrapper.get_distance_from_api(origin, destination, mode='driving')
self.wrapper._construct_request_string. \
assert_called_once_with(origin, destination, 'driving')
def test_get_address_without_route_generator_new_address_second_time(self):
handler = DatabaseHandler('unit_test_db.sqlite3')
handler.add_address(location=MapLocation(latitude=1, longitude=1))
handler.add_address(location=MapLocation(latitude=2, longitude=2))
address_generator = handler.get_address_generator()
self.assertEqual(MapLocation(latitude=1, longitude=1, id=1),
address_generator.next(),
"first returned MapLocation was not correct")
self.assertEqual(MapLocation(latitude=2, longitude=2, id=2),
address_generator.next(),
"second returned MapLocation was not correct")
def test_get_address_without_route_returns_address_without_route(self):
handler = DatabaseHandler('unit_test_db.sqlite3')
handler.add_address(location=MapLocation(latitude=1, longitude=2))
handler.add_address(location=MapLocation(latitude=3, longitude=4))
handler.add_stop(location=MapLocation(latitude=0, longitude=0))
c = handler.conn.cursor()
c.execute("INSERT INTO routes (address_id, stop_id, distance, time)"
"VALUES (1, 1, 1, 1)")
c.close()
address_generator = handler.get_address_generator()
self.assertEqual(MapLocation(latitude=3, longitude=4, id=2),
address_generator.next(),
"the MapLocation without route was not returned")
def test_add_stop_uses_MapLocation_id_if_nonzero(self, mock_init_db):
handler = DatabaseHandler('unit_test_db.sqlite3')
handler._add_stops_table()
stop_location = MapLocation(latitude=0.48, longitude=179, id=888)
handler.add_stop(stop_location)
c = handler.conn.cursor()
c.execute("SELECT * FROM stops")
self.assertEqual(888, c.fetchone()[0])
def test_add_address_uses_MapLocation_id_if_nonzero(self, mock_init_db):
handler = DatabaseHandler('unit_test_db.sqlite3')
handler._add_addresses_table()
address_location = MapLocation(latitude=0.33, longitude=4, id=100)
handler.add_address(address_location)
c = handler.conn.cursor()
c.execute("SELECT * FROM addresses")
self.assertEqual(100, c.fetchone()[0])
def test_add_address_adds_to_address_table(self, mock_init_db):
handler = DatabaseHandler('unit_test_db.sqlite3')
handler._add_addresses_table()
handler.add_address(location=MapLocation(latitude=0.56, longitude=9.5))
c = handler.conn.cursor()
c.execute("SELECT latitude, longitude FROM addresses")
row = c.fetchone()
self.assertEqual((0.56, 9.5), row)
def test_add_stop_adds_to_stops_table(self, mock_init_db):
handler = DatabaseHandler('unit_test_db.sqlite3')
handler._add_stops_table()
map_location = MapLocation(latitude=-0.55, longitude=80)
handler.add_stop(location=map_location)
c = handler.conn.cursor()
c.execute("SELECT latitude, longitude FROM stops")
row = c.fetchone()
self.assertEqual((-.55, 80), row)
def get_all_stops(self):
c = self.conn.cursor()
c.execute("SELECT * from stops")
rows = c.fetchall()
c.close()
return [
MapLocation(latitude=row[1], longitude=row[2], id=row[0])
for row in rows
]
def test_routes_dataframe_closest_stops_returns_for_many_addresses(self):
handler = DatabaseHandler('unit_test_db.sqlite3')
handler.initialize_db()
handler.add_address(MapLocation(latitude=1, longitude=1, id=1))
handler.add_address(MapLocation(latitude=11, longitude=10, id=11))
handler.add_stop(MapLocation(latitude=2, longitude=2, id=2))
handler.add_stop(MapLocation(latitude=12, longitude=12, id=12))
handler.add_route(address=1, stop=2, distance=1, time=1)
handler.add_route(address=1, stop=12, distance=11, time=11)
handler.add_route(address=11, stop=2, distance=9, time=9)
handler.add_route(address=11, stop=12, distance=1, time=1)
df = handler.routes_dataframe_closest_stops()
self.assertEqual(
2, df.shape[0], "should be 2 output rows since "
"there are 2 addresses with routes")
self.assertEqual(
1, df.ix[0, 'distance'], "distance for the first row should be 1 "
"since that is the shortest route distance")
def test_routes_dataframe_has_correct_values(self):
handler = DatabaseHandler('unit_test_db.sqlite3')
handler.initialize_db()
handler.add_address(MapLocation(latitude=11, longitude=50, id=11))
handler.add_stop(MapLocation(latitude=-10, longitude=3, id=800))
handler.add_route(address=11, stop=800, distance=10000, time=50000)
df = handler.routes_dataframe()
self.assertEqual(1, df.shape[0], "only one row should be output")
self.assertEqual(11, df.ix[0, 'address_latitude'],
'incorrect address latitude output')
self.assertEqual(50, df.ix[0, 'address_longitude'],
'incorrect address longitude output')
self.assertEqual(-10, df.ix[0, 'stop_latitude'],
'incorrect stop latitude output')
self.assertEqual(3, df.ix[0, 'stop_longitude'],
'incorrect stop longitude output')
self.assertEqual(10000, df.ix[0, 'distance'],
'incorrect distance output')
self.assertEqual(50000, df.ix[0, 'time'], 'incorrect time output')
def get_address_generator(self, verbose=False):
c = self.conn.cursor()
c.execute("SELECT "
"addresses.latitude, addresses.longitude, addresses.id "
"FROM addresses LEFT JOIN routes "
"ON routes.address_id = addresses.id "
"WHERE routes.id IS NULL")
if verbose:
print("fetching all addresses without routes...")
rows = c.fetchall()
c.close()
if verbose:
print("fetched {} addresses".format(len(rows)))
for row in rows:
yield MapLocation(latitude=row[0], longitude=row[1], id=row[2])
def test_output_routes_outputs_correctly_for_one_route(self):
handler = DatabaseHandler('unit_test_db.sqlite3')
handler.initialize_db()
handler.add_address(MapLocation(latitude=3, longitude=4, id=1))
handler.add_stop(MapLocation(latitude=9, longitude=10, id=1))
handler.add_route(address=1, stop=1, distance=50, time=100)
handler.output_routes(file_path='test_file.csv')
self.assertTrue(os.path.exists('test_file.csv'),
'test_file.csv file not found')
output = pd.read_csv('test_file.csv')
self.assertNotEqual(0, output.shape[0],
"no output rows in output .csv")
self.assertEqual(3, output.ix[0, 'address_latitude'],
'incorrect address latitude output')
self.assertEqual(4, output.ix[0, 'address_longitude'],
'incorrect address longitude output')
self.assertEqual(9, output.ix[0, 'stop_latitude'],
'incorrect stop latitude output')
self.assertEqual(10, output.ix[0, 'stop_longitude'],
'incorrect stop longitude output')
self.assertEqual(50, output.ix[0, 'distance'],
'incorrect distance output')
self.assertEqual(100, output.ix[0, 'time'], 'incorrect time output')
def test_routes_dataframe_only_grabs_routes_no_dangling_locations(self):
handler = DatabaseHandler('unit_test_db.sqlite3')
handler.initialize_db()
handler.add_address(MapLocation(latitude=1, longitude=1, id=1))
handler.add_address(MapLocation(latitude=2, longitude=2, id=2))
handler.add_address(MapLocation(latitude=3, longitude=3, id=3))
handler.add_stop(MapLocation(latitude=11, longitude=11, id=11))
handler.add_stop(MapLocation(latitude=12, longitude=12, id=12))
handler.add_stop(MapLocation(latitude=13, longitude=13, id=13))
handler.add_route(address=1, stop=11, distance=100, time=1000)
handler.add_route(address=3, stop=13, distance=100, time=1000)
df = handler.routes_dataframe()
self.assertEqual(2, df.shape[0], "should be 2 output rows")
self.assertEqual(1, df.ix[0, 'address_latitude'],
'incorrect address latitude output')
self.assertEqual(3, df.ix[1, 'address_latitude'],
'incorrect address latitude output')
self.assertEqual(11, df.ix[0, 'stop_latitude'],
'incorrect stop latitude output')
self.assertEqual(13, df.ix[1, 'stop_latitude'],
'incorrect stop latitude output')
def test_different_MapLocations_are_not_equal(self):
a = MapLocation(latitude=4, longitude=7)
b = MapLocation(latitude=5, longitude=5)
self.assertTrue(
a != b, "MapLocations with different latitudes and "
"longitudes should not be equal")
def test_constuct_request_string_errors_if_empty_key(self):
with self.assertRaises(UnboundLocalError):
self.wrapper._construct_request_string(MapLocation(),
MapLocation())
def test_construct_request_string_returns_string(self):
self.wrapper.key = 'api_key'
request_string = self.wrapper._construct_request_string(
MapLocation(), MapLocation())
self.assertIsInstance(request_string, str)
def test_MapLocation_accepts_id_in_constructor(self):
location = MapLocation(latitude=1, longitude=2, id=15)
self.assertEqual(15, location.id)
def test_locations_can_be_ordered_opposite(self):
a = MapLocation(latitude=2, longitude=2, id=2)
b = MapLocation(latitude=1, longitude=1, id=1)
self.assertTrue(a > b, "MapLocations should be able to be ordered")
def test_constructor_instantiates_latitude_zero_as_default(self):
location = MapLocation()
self.assertEquals(0, location.latitude)
def test_get_address_without_route_generator_yield_MapLocations(self):
handler = DatabaseHandler('unit_test_db.sqlite3')
handler.add_address(location=MapLocation(latitude=1, longitude=1))
address_generator = handler.get_address_generator()
self.assertIsInstance(address_generator.next(), MapLocation)
def test_str_method_is_correct(self):
location = MapLocation(latitude=4, longitude=5)
self.assertEqual("4, 5", str(location))