def test_bad_parse(self):
invalid = {"service": ["google"], "bounds": ["1.0,2.0|3.0,4.0"]}
mock_handler = MockRequestHandler(invalid)
response = GeoproxyResponse()
mock_services = {"google": None, "here": None}
req_parser = GeoproxyRequestParser(mock_services, response)
out = req_parser.parse(mock_handler)
# missing address
self.assertFalse(out)
self.assertEqual(response.status, "INVALID_REQUEST")
def test_bad_parse2(self):
invalid = {"address": ["Addr"], "service": ["blah"], "bounds": ["1.0,2.0|3.0,4.0"]}
mock_handler = MockRequestHandler(invalid)
response = GeoproxyResponse()
mock_services = {"google": None, "here": None}
req_parser = GeoproxyRequestParser(mock_services, response)
out = req_parser.parse(mock_handler)
self.assertTrue(out)
# invalid primary service
self.assertTrue(all(elem in req_parser.services for elem in ["google", "here"]))
self.assertEqual(response.query, "Addr")
def test_here_parse(self):
valid = {"address": ["Addr"], "service": ["here"], "bounds": ["1.0,2.0|3.0,4.0"]}
mock_handler = MockRequestHandler(valid)
response = GeoproxyResponse()
mock_services = {"google": None, "here": None}
req_parser = GeoproxyRequestParser(mock_services, response)
out = req_parser.parse(mock_handler)
self.assertTrue(out)
self.assertEqual(req_parser.address, "Addr")
self.assertEqual(req_parser.services, ["here", "google"])
self.assertEqual(req_parser.bounds.top_left.latitude, 3.0)
def get(self):
"""Request handler for method=GET
Responsible for spawning third party geocoder query tasks based on parsed request data
Pseudo code:
- Create empty response
- Parse incoming request
- If parse success:
- For each third party service:
- Build third party service query from incoming request data
- Spawn query task and wait on future for third party response
- Parse third party response
- If success:
- Set response result
- Break
- Next service in loop
- Else:
- Set response error
- Send response
"""
start_time = time.time()
# Create an empty API response
geo_proxy_response = GeoproxyResponse()
try:
# Next, parse the inputs from the RESTful query and ensure they are all valid
geo_proxy_request = GeoproxyRequestParser(self.available_services,
geo_proxy_response)
# if our request parse succeeds, we have valid input data and can proceed
if geo_proxy_request.parse(self):
self.logger.info(
"Incoming request:\n{}".format(geo_proxy_request))
# iterate through each service in request.services until we get a successful result
for service in geo_proxy_request.services:
self.logger.info(
"Querying third-party service: {}".format(service))
# Grab the third party helper object, associated with the service
# The helper assists with third party query construction and parsing
service_helper = self.available_services[service]
# build the third party query based on our request inputs
service_helper.build_query(geo_proxy_request.address,
geo_proxy_request.bounds)
# run the query and yield the response
response_json = yield self.query_third_party_geocoder(
service_helper.query)
if response_json:
# if we got a valid response from the third party query, parse it!
parse_success = service_helper.parser.parse(
response_json)
# fragile detection if there was a valid response, but zero results
if parse_success == 0:
geo_proxy_response.set_error(
"Zero results", "ZERO_RESULTS")
# otherwise assume the parse was successful, and we extracted data
# package it into our response object to be sent out.
elif parse_success is not None:
geo_proxy_response.error = None
geo_proxy_response.set_result(
service, service_helper.parser.latitude,
service_helper.parser.longitude,
service_helper.parser.address)
# if we get a valid result, don't keep querying the other third
# party services
# NOTE: Making an assumption that we are only returning results from the
# first valid third party service
break
# if we had an error with both service requests, but no error has been set, do it now
# this handles cases like wrong API keys, offline services, etc.
if not geo_proxy_response.status == "OK" and geo_proxy_response.error is None:
geo_proxy_response.set_error(
"Error in third-party API requests", "UNKNOWN_ERROR")
except Exception as e:
geo_proxy_response.set_error(
"Caught general exception in server: {}".format(e),
"UNKNOWN_ERROR")
# Ensure that a response is always sent so the socket doesn't bind
self.write(geo_proxy_response.to_json())
self.logger.info(
"Response completed in {:0.2f} seconds".format(time.time() -
start_time))