def test_similar_journeys_different_transfer():
"""
If 2 journeys take the same vjs but with a different number of sections,
one should be filtered
"""
responses = [response_pb2.Response()]
journey1 = responses[0].journeys.add()
journey1.sections.add()
journey1.duration = 42
journey1.sections[-1].uris.vehicle_journey = 'bob'
journey1.sections.add()
journey1.duration = 42
journey1.sections[-1].uris.vehicle_journey = 'bobette'
responses.append(response_pb2.Response())
journey2 = responses[-1].journeys.add()
journey2.sections.add()
journey2.duration = 43
journey2.sections[-1].uris.vehicle_journey = 'bob'
journey2.sections.add()
journey2.duration = 43
journey2.sections[-1].type = response_pb2.TRANSFER
journey2.sections.add()
journey2.duration = 43
journey2.sections[-1].uris.vehicle_journey = 'bobette'
jf.filter_similar_vj_journeys(journey_pairs_gen(responses), {})
assert 'to_delete' not in journey1.tags
assert 'to_delete' in journey2.tags
def test_too_late_journeys():
request = {
'datetime':
1000,
'_night_bus_filter_max_factor':
default_values.night_bus_filter_max_factor,
'_night_bus_filter_base_factor':
default_values.night_bus_filter_base_factor,
}
responses = [response_pb2.Response()]
journey1 = responses[0].journeys.add()
journey1.departure_date_time = 2000
journey1.arrival_date_time = 3000
journey2 = responses[0].journeys.add(
) # later than journey1, but acceptable
journey2.departure_date_time = 2700
journey2.arrival_date_time = 5000
responses.append(response_pb2.Response()) # too late compared to journey1
journey3 = responses[-1].journeys.add()
journey3.departure_date_time = 10000
journey3.arrival_date_time = 13000
journey_filter._filter_too_long_journeys(responses, request)
assert 'to_delete' not in journey1.tags
assert 'to_delete' not in journey2.tags
assert 'to_delete' in journey3.tags
def test_not_too_late_journeys_non_clockwise():
request = {
'datetime':
12000,
'clockwise':
False,
'_night_bus_filter_max_factor':
default_values.night_bus_filter_max_factor,
'_night_bus_filter_base_factor':
default_values.night_bus_filter_base_factor,
}
responses = [response_pb2.Response()]
journey1 = responses[0].journeys.add()
journey1.departure_date_time = 2000 # way too soon compared to the second one
journey1.arrival_date_time = 3000
responses.append(response_pb2.Response())
journey2 = responses[-1].journeys.add()
journey2.departure_date_time = 10000
journey2.arrival_date_time = 11000
journey3 = responses[-1].journeys.add() # before journey2, but acceptable
journey3.departure_date_time = 8000
journey3.arrival_date_time = 9000
journey_filter._filter_too_long_journeys(responses, request)
assert 'to_delete' in journey1.tags
assert 'to_delete' not in journey2.tags
assert 'to_delete' not in journey3.tags
def test_similar_journeys_multi_trasfer_and_different_waiting_durations():
"""
If 2 journeys take the same vj, same number of sections and several waitings with different waiting durations,
for each journey find "min waiting duration"
keep the journey which has larger "min waiting duration"
"""
responses = [response_pb2.Response()]
journey1 = responses[0].journeys.add()
journey1.duration = 1000
journey1.sections.add()
journey1.sections[-1].uris.vehicle_journey = 'bob'
journey1.sections[-1].duration = 200
journey1.sections.add()
journey1.sections[-1].type = response_pb2.TRANSFER
journey1.sections[-1].duration = 50
journey1.sections.add()
journey1.sections[-1].type = response_pb2.WAITING
journey1.sections[-1].duration = 150
journey1.sections.add()
journey1.sections[-1].uris.vehicle_journey = 'bobette'
journey1.sections[-1].duration = 200
journey1.sections.add()
journey1.sections[-1].type = response_pb2.TRANSFER
journey1.sections[-1].duration = 10
journey1.sections.add()
journey1.sections[-1].type = response_pb2.WAITING
journey1.sections[-1].duration = 190
journey1.sections.add()
journey1.sections[-1].uris.vehicle_journey = 'boby'
journey1.sections[-1].duration = 200
responses.append(response_pb2.Response())
journey2 = responses[-1].journeys.add()
journey2.duration = 1000
journey2.sections.add()
journey2.sections[-1].uris.vehicle_journey = 'bob'
journey2.sections[-1].duration = 200
journey2.sections.add()
journey2.sections[-1].type = response_pb2.TRANSFER
journey2.sections[-1].duration = 20
journey2.sections.add()
journey2.sections[-1].type = response_pb2.WAITING
journey2.sections[-1].duration = 180
journey2.sections.add()
journey2.sections[-1].uris.vehicle_journey = 'bobette'
journey2.sections[-1].duration = 200
journey2.sections.add()
journey2.sections[-1].type = response_pb2.TRANSFER
journey2.sections[-1].duration = 100
journey2.sections.add()
journey2.sections[-1].type = response_pb2.WAITING
journey2.sections[-1].duration = 100
journey2.sections.add()
journey2.sections[-1].uris.vehicle_journey = 'boby'
journey2.sections[-1].duration = 200
jf.filter_similar_vj_journeys(list(journey_pairs_gen(responses)), {})
assert 'to_delete' not in journey1.tags
assert 'to_delete' in journey2.tags
def merge_responses_feed_publishers_test():
"""
Check that the feed publishers are exposed according to the itineraries
"""
resp1 = response_pb2.Response()
fp1 = resp1.feed_publishers.add()
fp1.id = "Bobby"
j1 = resp1.journeys.add()
resp2 = response_pb2.Response()
fp2 = resp2.feed_publishers.add()
fp2.id = "Bobbette"
j2 = resp2.journeys.add()
r = [resp1, resp2]
# The feed publishers of both journeys are exposed
merged_response = new_default.merge_responses(r, False)
assert len(merged_response.feed_publishers) == 2
# The 2nd journey is to be deleted, the feed publisher should still be exposed
resp2.journeys.add().tags.extend(['to_delete'])
merged_response = new_default.merge_responses(r, False)
assert len(merged_response.feed_publishers) == 2
assert merged_response.feed_publishers[0].id == 'Bobby'
# All journeys are tagged as 'to_delete', no feed publishers should be exposed
j1.tags.extend(['to_delete'])
j2.tags.extend(['to_delete'])
merged_response = new_default.merge_responses([resp1, resp2], False)
assert len(merged_response.feed_publishers) == 0
# With 'debug=True', the journey to delete is exposed and so is its feed publisher
merged_response = new_default.merge_responses(r, True)
assert len(merged_response.feed_publishers) == 2
def test_too_late_journeys_and_worst_mode():
request = {
'datetime': 1000000,
'clockwise': True,
'_night_bus_filter_max_factor': 2,
'_night_bus_filter_base_factor': 9,
}
responses = [response_pb2.Response()]
walking = responses[0].journeys.add()
walking.departure_date_time = 1001042
walking.arrival_date_time = 1002000
walking.tags.append('walking')
responses.append(response_pb2.Response())
bss = responses[-1].journeys.add()
bss.departure_date_time = 1001042
bss.arrival_date_time = 1004010 # walking * 2 + 10
bss.tags.append('bss')
responses.append(response_pb2.Response())
bike = responses[-1].journeys.add()
bike.departure_date_time = 1001042
bike.arrival_date_time = 1008030 # bss * 2 + 10
bike.tags.append('bike')
responses.append(response_pb2.Response())
car = responses[-1].journeys.add()
car.departure_date_time = 1001042
car.arrival_date_time = 1016070 # bike * 2 + 10
car.tags.append('car')
journey_filter._filter_too_long_journeys(responses, request)
assert ['to_delete' not in j.tags for r in responses
for j in r.journeys].count(True) == 1
def test_too_late_journeys_but_better_mode():
request = {'datetime': 1000000,
'clockwise': True,
'_night_bus_filter_max_factor': 2,
'_night_bus_filter_base_factor': 9,
}
responses = [response_pb2.Response()]
car = responses[0].journeys.add()
car.departure_date_time = 1001042
car.arrival_date_time = 1002000
car.tags.append('car')
responses.append(response_pb2.Response())
bike = responses[-1].journeys.add()
bike.departure_date_time = 1001042
bike.arrival_date_time = 1004010 # car * 2 + 10
bike.tags.append('bike')
responses.append(response_pb2.Response())
bss = responses[-1].journeys.add()
bss.departure_date_time = 1001042
bss.arrival_date_time = 1008030 # bike * 2 + 10
bss.tags.append('bss')
responses.append(response_pb2.Response())
walking = responses[-1].journeys.add()
walking.departure_date_time = 1001042
walking.arrival_date_time = 1016070 # bss * 2 + 10
walking.tags.append('walking')
journey_filter._filter_too_long_journeys(list(journeys_gen(responses)),
MockInstance(), request)
assert all('to_delete' not in j.tags for r in responses for j in r.journeys)
def _direct_path(
self,
instance,
mode,
pt_object_origin,
pt_object_destination,
fallback_extremity,
request,
direct_path_type,
request_id,
):
# if the crowfly distance between origin and destination is too large, there is no need to call asgard
crowfly_distance = crowfly_distance_between(
get_pt_object_coord(pt_object_origin),
get_pt_object_coord(pt_object_destination))
# if the crowfly distance between origin and destination is
# bigger than max_{mode}_direct_path_distance don't compute direct_path
if crowfly_distance > int(
request['max_{mode}_direct_path_distance'.format(mode=mode)]):
return response_pb2.Response()
if (crowfly_distance / float(request['{mode}_speed'.format(mode=mode)])
>
request['max_{mode}_direct_path_duration'.format(mode=mode)]):
return response_pb2.Response()
language = self.get_language_parameter(request)
req = self._create_direct_path_request(
mode,
pt_object_origin,
pt_object_destination,
fallback_extremity,
request,
direct_path_type,
language,
)
response = self._call_asgard(req)
# car_no_park is interpreted as car for Asgard, we need to overwrite the streetnetwork mode here
if mode == "car_no_park":
try:
response.journeys[0].sections[
0].street_network.mode = response_pb2.CarNoPark
except AttributeError:
pass
except Exception as e:
raise e
if response and mode in (FallbackModes.bike.name,
FallbackModes.bss.name):
response = self._add_cycle_lane_length(response)
return response
def test_similar_journeys_bss_park():
"""
We have to consider a journey with
WALK / GET A BIKE / BSS to be equals to GET A BIKE / BSS
"""
responses = [response_pb2.Response()]
journey1 = response_pb2.Journey()
journey1.sections.add()
journey1.sections[-1].type = response_pb2.STREET_NETWORK
journey1.sections[-1].street_network.mode = response_pb2.Walking
journey1.sections.add()
journey1.sections[-1].type = response_pb2.BSS_RENT
journey1.sections.add()
journey1.sections[-1].type = response_pb2.STREET_NETWORK
journey1.sections[-1].street_network.mode = response_pb2.Bss
journey2 = response_pb2.Journey()
journey2.sections.add()
journey2.sections[-1].type = response_pb2.BSS_RENT
journey2.sections.add()
journey2.sections[-1].type = response_pb2.STREET_NETWORK
journey2.sections[-1].street_network.mode = response_pb2.Bss
assert journey_filter.compare(journey1, journey2,
journey_filter.similar_journeys_vj_generator)
def test_similar_journeys_car_park():
"""
We have to consider a journey with
CAR / PARK / WALK to be equal to CAR / PARK
"""
responses = [response_pb2.Response()]
journey1 = response_pb2.Journey()
journey1.sections.add()
journey1.sections[-1].type = response_pb2.STREET_NETWORK
journey1.sections[-1].street_network.mode = response_pb2.Car
journey1.sections.add()
journey1.sections[-1].type = response_pb2.PARK
journey1.sections.add()
journey1.sections[-1].type = response_pb2.STREET_NETWORK
journey1.sections[-1].street_network.mode = response_pb2.Walking
journey2 = response_pb2.Journey()
journey2.sections.add()
journey2.sections[-1].type = response_pb2.STREET_NETWORK
journey2.sections[-1].street_network.mode = response_pb2.Car
journey2.sections.add()
journey2.sections[-1].type = response_pb2.PARK
assert journey_filter.compare(journey1, journey2,
journey_filter.similar_journeys_vj_generator)
def _direct_path(self, mode, pt_object_origin, pt_object_destination,
fallback_extremity, request, direct_path_type):
params = self.get_direct_path_params(pt_object_origin,
pt_object_destination, mode,
fallback_extremity)
r = self._call_here(self.routing_service_url, params=params)
if r.status_code != 200:
self.log.debug(
'impossible to find a path between {o} and {d}, response ({code}) {r}'
.format(o=pt_object_origin,
d=pt_object_destination,
code=r.status_code,
r=r.text))
resp = response_pb2.Response()
resp.status_code = 200
resp.response_type = response_pb2.NO_SOLUTION
return resp
json = r.json()
self.log.debug('here response = {}'.format(json))
return self._read_response(json, pt_object_origin,
pt_object_destination, mode,
fallback_extremity, request)
def _make_error_response(message, error_id):
from navitiacommon import response_pb2
r = response_pb2.Response()
r.error.message = message
r.error.id = error_id
return r
def different_nb_transfers_test():
script = Script()
response = response_pb2.Response()
journey1 = response.journeys.add()
journey1.arrival_date_time = "20140422T0800"
journey1.duration = 25 * 60
journey1.nb_transfers = 1
journey1.sections.add()
journey1.sections.add()
journey1.sections.add()
journey1.sections.add()
journey1.sections[0].type = response_pb2.PUBLIC_TRANSPORT
journey1.sections[0].duration = 5 * 60
journey1.sections[1].type = response_pb2.TRANSFER
journey1.sections[1].duration = 3 * 60
journey1.sections[2].type = response_pb2.WAITING
journey1.sections[2].duration = 2 * 60
journey1.sections[3].type = response_pb2.PUBLIC_TRANSPORT
journey1.sections[3].duration = 15 * 60
journey2 = response.journeys.add()
journey2.arrival_date_time = "20140422T0800"
journey2.duration = 25 * 60
journey2.nb_transfers = 0
journey2.sections.add()
journey2.sections[0].type = response_pb2.PUBLIC_TRANSPORT
journey2.sections[0].duration = 25 * 60
script.sort_journeys(response)
assert response.journeys[0].arrival_date_time == "20140422T0800"
assert response.journeys[1].arrival_date_time == "20140422T0800"
assert response.journeys[0].duration == 25 * 60
assert response.journeys[1].duration == 25 * 60
assert response.journeys[0].nb_transfers == 0
assert response.journeys[1].nb_transfers == 1
def crowfly_in_ridesharing_test():
response = response_pb2.Response()
journey = response.journeys.add()
section_crowfly = journey.sections.add()
section_crowfly.type = response_pb2.CROW_FLY
section_crowfly.street_network.mode = response_pb2.Car
section_crowfly.duration = 42
section_crowfly.length = 43
journey.distances.car = 43
journey.durations.car = 42
section = journey.sections.add()
section.type = response_pb2.PUBLIC_TRANSPORT
section = journey.sections.add()
section.type = response_pb2.STREET_NETWORK
section.street_network.mode = response_pb2.Walking
switch_back_to_ridesharing(response, True)
assert section_crowfly.street_network.mode == response_pb2.Ridesharing
assert journey.durations.ridesharing == 42
assert journey.durations.car == 0
assert journey.distances.ridesharing == 43
assert journey.distances.car == 0
def _direct_path(
self,
instance,
mode,
pt_object_origin,
pt_object_destination,
fallback_extremity,
request,
direct_path_type,
):
data = self._make_request_arguments(mode, [pt_object_origin],
[pt_object_destination],
request,
api='route')
r = self._call_valhalla('{}/{}'.format(self.service_url, 'route'),
requests.post, data)
if r is not None and r.status_code == 400 and r.json(
)['error_code'] == 442:
# error_code == 442 => No path could be found for input
resp = response_pb2.Response()
resp.status_code = 200
resp.response_type = response_pb2.NO_SOLUTION
return resp
self._check_response(r)
resp_json = r.json()
return self._get_response(
resp_json,
mode,
pt_object_origin,
pt_object_destination,
fallback_extremity,
direct_path_type,
mode_park_cost=self.mode_park_cost.get(mode),
)
def _send_and_receive(self,
request,
timeout=app.config.get('INSTANCE_TIMEOUT', 10000),
quiet=False,
**kwargs):
with self.socket(self.context) as socket:
try:
request.request_id = flask.request.id
except RuntimeError:
#we aren't in a flask context, so there is no request
if 'request_id' in kwargs:
request.request_id = kwargs['request_id']
socket.send(request.SerializeToString())
if socket.poll(timeout=timeout) > 0:
pb = socket.recv()
resp = response_pb2.Response()
resp.ParseFromString(pb)
self.update_property(
resp
) #we update the timezone and geom of the instances at each request
return resp
else:
socket.setsockopt(zmq.LINGER, 0)
socket.close()
if not quiet:
logger = logging.getLogger(__name__)
logger.error('request on %s failed: %s', self.socket_path,
unicode(request))
raise DeadSocketException(self.name, self.socket_path)
def different_nb_transfers_test():
response = response_pb2.Response()
journey1 = response.journeys.add()
journey1.arrival_date_time = str_to_time_stamp("20140422T0800")
journey1.duration = 25 * 60
journey1.nb_transfers = 1
journey1.sections.add()
journey1.sections.add()
journey1.sections.add()
journey1.sections.add()
journey1.sections[0].type = response_pb2.PUBLIC_TRANSPORT
journey1.sections[0].duration = 5 * 60
journey1.sections[1].type = response_pb2.TRANSFER
journey1.sections[1].duration = 3 * 60
journey1.sections[2].type = response_pb2.WAITING
journey1.sections[2].duration = 2 * 60
journey1.sections[3].type = response_pb2.PUBLIC_TRANSPORT
journey1.sections[3].duration = 15 * 60
journey2 = response.journeys.add()
journey2.arrival_date_time = str_to_time_stamp("20140422T0800")
journey2.duration = 25 * 60
journey2.nb_transfers = 0
journey2.sections.add()
journey2.sections[0].type = response_pb2.PUBLIC_TRANSPORT
journey2.sections[0].duration = 25 * 60
sort_journeys(response, 'arrival_time', True)
assert response.journeys[0].arrival_date_time == str_to_time_stamp("20140422T0800")
assert response.journeys[1].arrival_date_time == str_to_time_stamp("20140422T0800")
assert response.journeys[0].duration == 25 * 60
assert response.journeys[1].duration == 25 * 60
assert response.journeys[0].nb_transfers == 0
assert response.journeys[1].nb_transfers == 1
def different_duration_test():
scenario = Scenario()
response = response_pb2.Response()
journey1 = response.journeys.add()
journey1.arrival_date_time = str_to_time_stamp("20140422T0800")
journey1.duration = 5 * 60
journey1.nb_transfers = 0
journey1.sections.add()
journey1.sections[0].type = response_pb2.PUBLIC_TRANSPORT
journey1.sections[0].duration = 5 * 60
journey2 = response.journeys.add()
journey2.arrival_date_time = str_to_time_stamp("20140422T0800")
journey2.duration = 3 * 60
journey2.nb_transfers = 0
journey2.sections.add()
journey2.sections[0].type = response_pb2.PUBLIC_TRANSPORT
journey2.sections[0].duration = 3 * 60
scenario.sort_journeys(response, 'arrival_time')
assert response.journeys[0].arrival_date_time == str_to_time_stamp(
"20140422T0800")
assert response.journeys[1].arrival_date_time == str_to_time_stamp(
"20140422T0800")
assert response.journeys[0].duration == 3 * 60
assert response.journeys[1].duration == 5 * 60
def build_mocked_response():
response = response_pb2.Response()
for jrny in JOURNEYS:
arrival_time, jrny_type, sections_idx = jrny
pb_j = response.journeys.add()
pb_j.arrival_date_time = arrival_time
# we remove the street network section
pb_j.nb_transfers = len(sections_idx) - 1 - (1 in sections_idx) - (
10 in sections_idx)
if jrny_type:
pb_j.type = jrny_type
for idx in sections_idx:
section_type, network_mode, line_uri = SECTIONS_CHOICES[idx]
section = pb_j.sections.add()
section.type = section_type
if network_mode:
section.street_network.mode = network_mode
if line_uri:
section.uris.line = line_uri
new_default._tag_by_mode([response])
new_default._tag_direct_path([response])
new_default._tag_bike_in_pt([response])
return response
def _send_and_receive(self, request, quiet=False, **kwargs):
logger = logging.getLogger(__name__)
deadline = datetime.utcnow() + timedelta(milliseconds=self.timeout)
request.deadline = deadline.strftime('%Y%m%dT%H%M%S,%f')
with self.socket(self.context) as socket:
if 'request_id' in kwargs and kwargs['request_id']:
request.request_id = kwargs['request_id']
else:
try:
request.request_id = flask.request.id
except RuntimeError:
# we aren't in a flask context, so there is no request
if 'flask_request_id' in kwargs and kwargs['flask_request_id']:
request.request_id = kwargs['flask_request_id']
socket.send(request.SerializeToString())
if socket.poll(timeout=self.timeout) > 0:
pb = socket.recv()
resp = response_pb2.Response()
resp.ParseFromString(pb)
return resp
else:
socket.setsockopt(zmq.LINGER, 0)
socket.close()
if not quiet:
logger.error('request on %s failed: %s', self.zmq_socket, six.text_type(request))
raise DeadSocketException(self.name, self.zmq_socket)
def merge_responses(responses, debug):
"""
Merge all responses in one protobuf response
"""
merged_response = response_pb2.Response()
for response_index, r in enumerate(responses):
if r.HasField(str('error')) or not r.journeys:
# we do not take responses with error, but if all responses have errors, we'll aggregate them
continue
change_ids(r, response_index)
# we don't want to add a journey already there
merged_response.journeys.extend(r.journeys)
# we have to add the additional fares too
# if at least one journey has the ticket we add it
tickets_to_add = set(t for j in r.journeys for t in j.fare.ticket_id)
merged_response.tickets.extend(
(t for t in r.tickets if t.id in tickets_to_add))
initial_feed_publishers = {}
for fp in merged_response.feed_publishers:
initial_feed_publishers[fp.id] = fp
# Add feed publishers from the qualified journeys only
# Note : For BSS, it can happen that one journey in the response has returned a walking fallback.
# If all other journeys in the response are to delete, the feed publisher will still be added
# TODO: link feed publisher to a journey instead of a response with several journeys
merged_response.feed_publishers.extend(
fp for fp in r.feed_publishers
if fp.id not in initial_feed_publishers and (debug or all(
'to_delete' not in j.tags for j in r.journeys)))
# handle impacts
for i in r.impacts:
if any(other.uri == i.uri for other in merged_response.impacts):
continue
merged_response.impacts.extend([i])
if not merged_response.journeys:
# we aggregate the errors found
errors = {
r.error.id: r.error
for r in responses if r.HasField(str('error'))
}
# Only one errors field
if len(errors) == 1:
merged_response.error.id = list(errors.values())[0].id
merged_response.error.message = list(errors.values())[0].message
# we need to merge the errors
elif len(errors) > 1:
merged_response.error.id = response_pb2.Error.no_solution
merged_response.error.message = "several errors occured: \n * {}".format(
"\n * ".join([m.message for m in errors.values()]))
return merged_response
def alternative_route_response(profiles_params):
response = response_pb2.Response()
response.response_type = response_pb2.ITINERARY_FOUND
for params in profiles_params:
journey = response.journeys.add()
journey.tags.append(params.profile_tag)
journey_response(journey, params.origin_mode)
return response
def similar_journeys_test3():
responses = [response_pb2.Response()]
journey1 = responses[0].journeys.add()
journey1.sections.add()
journey1.duration = 42
journey1.sections[0].uris.vehicle_journey = 'bob'
responses.append(response_pb2.Response())
journey2 = responses[-1].journeys.add()
journey2.sections.add()
journey2.duration = 43
journey2.sections[-1].uris.vehicle_journey = 'bobette'
journey_filter._filter_similar_journeys(journeys_gen(responses), {})
assert journey2 in journeys_gen(responses)
def test_similar_journeys_test2():
responses = [response_pb2.Response()]
journey1 = responses[0].journeys.add()
journey1.sections.add()
journey1.duration = 42
journey1.sections[0].uris.vehicle_journey = 'bob'
responses.append(response_pb2.Response())
journey2 = responses[-1].journeys.add()
journey2.sections.add()
journey2.duration = 43
journey2.sections[-1].uris.vehicle_journey = 'bob'
jf.filter_similar_vj_journeys(list(journey_pairs_gen(responses)), {})
assert len(list(jf.get_qualified_journeys(responses))) == 1
def test_not_too_late_journeys():
request = {'datetime': 1000}
responses = [response_pb2.Response()]
journey1 = responses[0].journeys.add()
journey1.departure_date_time = 2000
journey1.arrival_date_time = 3000
responses.append(response_pb2.Response())
journey2 = responses[-1].journeys.add()
journey2.departure_date_time = 3100
journey2.arrival_date_time = 3200
journey_filter._filter_not_coherent_journeys(list(journeys_gen(responses)),
MockInstance(), request,
request)
assert 'to_delete' not in journey1.tags
assert 'to_delete' not in journey2.tags
def test_similar_journeys_test3():
responses = [response_pb2.Response()]
journey1 = responses[0].journeys.add()
journey1.sections.add()
journey1.duration = 42
journey1.sections[0].uris.vehicle_journey = 'bob'
responses.append(response_pb2.Response())
journey2 = responses[-1].journeys.add()
journey2.sections.add()
journey2.duration = 43
journey2.sections[-1].uris.vehicle_journey = 'bobette'
jf.filter_similar_vj_journeys(list(journey_pairs_gen(responses)), {})
assert 'to_delete' not in journey1.tags
assert 'to_delete' in journey2.tags
def sort_destineo_date_test():
"""
the bss journey must be first since it his on first day
"""
response = response_pb2.Response()
journey_tc3 = response.journeys.add()
journey_tc3.type = "rapid"
journey_tc3.departure_date_time = str_to_time_stamp('20141103T123000')
section = journey_tc3.sections.add()
section.type = response_pb2.STREET_NETWORK
section.street_network.mode = response_pb2.Walking
section = journey_tc3.sections.add()
section.type = response_pb2.PUBLIC_TRANSPORT
section = journey_tc3.sections.add()
section.type = response_pb2.STREET_NETWORK
section.street_network.mode = response_pb2.Walking
journey_tc1 = response.journeys.add()
journey_tc1.type = "rapid"
journey_tc1.departure_date_time = str_to_time_stamp('20141103T110000')
section = journey_tc1.sections.add()
section.type = response_pb2.STREET_NETWORK
section.street_network.mode = response_pb2.Walking
section = journey_tc1.sections.add()
section.type = response_pb2.PUBLIC_TRANSPORT
section = journey_tc1.sections.add()
section.type = response_pb2.STREET_NETWORK
section.street_network.mode = response_pb2.Walking
journey_bss_and_tc = response.journeys.add()
journey_bss_and_tc.departure_date_time = str_to_time_stamp(
'20141102T120000')
journey_bss_and_tc.type = "rapid"
section = journey_bss_and_tc.sections.add()
section.type = response_pb2.STREET_NETWORK
section.street_network.mode = response_pb2.Walking
section = journey_bss_and_tc.sections.add()
section.type = response_pb2.BSS_RENT
section = journey_bss_and_tc.sections.add()
section.type = response_pb2.STREET_NETWORK
section.street_network.mode = response_pb2.Bike
section = journey_bss_and_tc.sections.add()
section.type = response_pb2.BSS_PUT_BACK
section = journey_bss_and_tc.sections.add()
section.type = response_pb2.PUBLIC_TRANSPORT
section = journey_bss_and_tc.sections.add()
section.type = response_pb2.STREET_NETWORK
section.street_network.mode = response_pb2.Walking
scenario = destineo.Scenario()
scenario._custom_sort_journeys(response,
clockwise=True,
timezone='Africa/Abidjan')
assert response.journeys[0] == journey_bss_and_tc
assert response.journeys[1] == journey_tc1
assert response.journeys[2] == journey_tc3
def find_max_duration__counterclockwise_test():
response = response_pb2.Response()
journey1 = response.journeys.add()
journey1.type = "best"
section = journey1.sections.add()
section.type = response_pb2.STREET_NETWORK
section.street_network.mode = response_pb2.Walking
section.duration = 240
section = journey1.sections.add()
section.type = response_pb2.PUBLIC_TRANSPORT
section.duration = 300
section = journey1.sections.add()
section.type = response_pb2.STREET_NETWORK
section.street_network.mode = response_pb2.Walking
section.duration = 120
journey1.duration = sum(
[section.duration for section in journey1.sections])
journey1.arrival_date_time = 1418211071
journey1.departure_date_time = journey1.arrival_date_time - journey1.duration
journey2 = response.journeys.add()
journey2.type = "rapid"
section = journey2.sections.add()
section.type = response_pb2.STREET_NETWORK
section.street_network.mode = response_pb2.Walking
section.duration = 120
section = journey2.sections.add()
section.type = response_pb2.PUBLIC_TRANSPORT
section.duration = 300
section = journey2.sections.add()
section.type = response_pb2.STREET_NETWORK
section.street_network.mode = response_pb2.Walking
section.duration = 120
journey2.duration = sum(
[section.duration for section in journey2.sections])
journey2.arrival_date_time = 1418220071
journey2.departure_date_time = journey2.arrival_date_time - journey2.duration
journey3 = response.journeys.add()
journey3.type = "non_pt_walk"
section = journey3.sections.add()
section.type = response_pb2.STREET_NETWORK
section.street_network.mode = response_pb2.Walking
section.duration = 130
journey3.duration = sum(
[section.duration for section in journey3.sections])
journey3.arrival_date_time = 1418222071
journey3.departure_date_time = journey3.arrival_date_time - journey3.duration
scenario = default.Scenario()
eq_(scenario._find_max_duration(response.journeys, Instance(), False), 580)
scenario._delete_too_long_journey(response.journeys, Instance(), False)
eq_(len(response.journeys), 2)
eq_(response.journeys[0], journey2)
eq_(response.journeys[1], journey3)
def _get_response(self, json_resp, mode, pt_object_origin,
pt_object_destination, datetime):
map_mode = {
"walking": response_pb2.Walking,
"car": response_pb2.Car,
"bike": response_pb2.Bike
}
resp = response_pb2.Response()
resp.status_code = 200
resp.response_type = response_pb2.ITINERARY_FOUND
for leg in json_resp['trip']['legs']:
journey = resp.journeys.add()
journey.duration = leg['summary']['time']
journey.departure_date_time = datetime
journey.arrival_date_time = datetime + journey.duration
journey.durations.total = journey.duration
if mode == 'walking':
journey.durations.walking = journey.duration
section = journey.sections.add()
section.type = response_pb2.STREET_NETWORK
section.begin_date_time = journey.departure_date_time
section.end_date_time = journey.arrival_date_time
section.id = 'section_0'
section.duration = journey.duration
section.length = int(kilometers_to_meters(
leg['summary']['length']))
section.origin.CopyFrom(pt_object_origin)
section.destination.CopyFrom(pt_object_destination)
section.street_network.length = kilometers_to_meters(
leg['summary']['length'])
section.street_network.duration = leg['summary']['time']
section.street_network.mode = map_mode[mode]
for maneuver in leg['maneuvers']:
path_item = section.street_network.path_items.add()
if 'street_names' in maneuver and len(
maneuver['street_names']) > 0:
path_item.name = maneuver['street_names'][0]
path_item.length = kilometers_to_meters(maneuver['length'])
path_item.duration = maneuver['time']
# TODO: calculate direction
path_item.direction = 0
shape = self._decode(leg['shape'])
for sh in shape:
coord = section.street_network.coordinates.add()
coord.lon = sh[0]
coord.lat = sh[1]
return resp
def merge_responses_on_errors_test():
"""
check the merge responses when several errors are provided
"""
resp1 = response_pb2.Response()
resp1.error.id = response_pb2.Error.date_out_of_bounds
resp1.error.message = "you're out of the bound"
resp2 = response_pb2.Response()
resp2.error.id = response_pb2.Error.bad_format
resp2.error.message = "you've been bad"
r = [resp1, resp2]
merged_response = new_default.merge_responses(r, False)
assert merged_response.HasField(str('error'))
assert merged_response.error.id == response_pb2.Error.no_solution
# both messages must be in the composite error
assert resp1.error.message in merged_response.error.message
assert resp2.error.message in merged_response.error.message
