def test_delete_poi_type_for_one_instance(create_tyr_update_jobs):
resp = api_get('/v0/instances')
assert len(resp) == 1
resp = api_get('/v0/jobs/{}'.format(create_tyr_update_jobs))
assert len(resp.values()[0]) == 2
# Here a job having two poi data_sets is deleted
resp = api_delete('/v0/instances/{}/actions/delete_dataset/poi'.format(create_tyr_update_jobs))
assert resp['action'] == 'All poi datasets deleted for instance {}'.format(create_tyr_update_jobs)
resp = api_get('/v0/jobs/{}'.format(create_tyr_update_jobs))
assert len(resp.values()[0]) == 1
for dataset in resp.values()[0][0]['data_sets']:
assert dataset['type'] != 'poi'
def test_status_with_rabbitmq_down_and_heavy_checks_param(setup_database):
with requests_mock.mock() as m:
kirin.app.config["NAVITIA_URL"] = "http://navitia"
m.head("http://navitia", status_code=200)
resp = api_get("/status")
assert resp["output_rabbitmq"]["connection"] == "OK"
with RabbitmqTemporaryMocker("wrong_rabbit_url", "wrong_exchange",
"wrong_exchange_type") as _rabbit:
resp = api_get("/status")
# in real life, it returns "OK"
# as we don't change the kirin configuration and we don't reuse the configuration
assert resp["output_rabbitmq"]["connection"] == "KO"
# the heavy_checks
api_get("/status?heavy_checks=1")
assert resp["output_rabbitmq"]["connection"] == "KO"
def test_update_user_invalid_shape_scope(create_multiple_users, mock_rabbit):
"""
Update of a user with invalid shape_scope
"""
resp = api_get('/v0/users/')
assert len(resp) == 2
for user in resp:
assert_default_scop_shape(user)
user = {
'login': '******',
'email': '*****@*****.**',
"shape_scope": ["bob"]
}
resp, status = api_put(
'/v0/users/{}'.format(create_multiple_users['user1']),
check=False,
data=json.dumps(user),
content_type='application/json',
)
assert status == 400
assert "message" in resp
message = resp["message"]
assert "shape_scope" in message
assert (
message["shape_scope"] ==
u"The shape_scope argument must be in list ('admin', 'street', 'addr', 'poi', 'stop'), you gave bob"
)
assert mock_rabbit.call_count == 0
def test_status():
resp = api_get('/status')
assert 'version' in resp
assert 'db_pool_status' in resp
assert 'db_version' in resp
assert 'navitia_url' in resp
def test_delete_autocomplete(create_two_autocomplete_parameters):
resp = api_get('/v0/autocomplete_parameters/')
assert len(resp) == 2
resp = api_get('/v0/autocomplete_parameters/france')
assert resp['name'] == 'france'
_, status = api_delete('/v0/autocomplete_parameters/france',
check=False,
no_json=True)
assert status == 204
_, status = api_get('/v0/autocomplete_parameters/france', check=False)
assert status == 404
resp = api_get('/v0/autocomplete_parameters/')
assert len(resp) == 1
def test_delete_instance_by_id(create_instance):
resp = api_delete('/v0/instances/{}'.format(create_instance))
assert resp['id'] == create_instance
assert resp['discarded'] == True
# check response to get with different use cases
resp = api_get('/v0/instances/')
assert resp == []
resp = api_get('/v0/instances/fr')
assert resp == []
resp = api_get('/v0/instances/{}'.format(create_instance))
assert resp == []
# delete by id is idempotent
resp, status = api_delete('/v0/instances/{}'.format(create_instance), check=False)
assert status == 200
def test_add_user_with_geojson(mock_rabbit, geojson):
"""
creation of a user passing arguments as a json
"""
user = {
'login': '******',
'email': '*****@*****.**',
'shape': geojson,
'has_shape': True
}
data = json.dumps(user)
resp = api_post('/v0/users/', data=data, content_type='application/json')
def check(u):
gen = (k for k in user if k is not 'shape')
for k in gen:
assert u[k] == user[k]
assert u['end_point']['name'] == 'navitia.io'
assert u['type'] == 'with_free_instances'
assert u['block_until'] == None
check(resp)
assert resp['shape'] == geojson
resp = api_get('/v0/users/')
assert len(resp) == 1
check(resp[0])
assert resp[0]['shape'] == {}
assert mock_rabbit.called
def test_deletion_keys_and_auth(create_instance, mock_rabbit):
"""
We start by creating the user, it's easier than using a fixture, then we delete the auth and the key
"""
# first, test that with an unknown user, we get a 404
_, status = api_delete('/v0/users/75/keys/1', check=False, no_json=True)
assert status == 404
user = {'login': '******', 'email': '*****@*****.**'}
resp_user = api_post('/v0/users/',
data=json.dumps(user),
content_type='application/json')
api_post(
'/v0/users/{}/keys'.format(resp_user['id']),
data=json.dumps({'app_name': 'myApp'}),
content_type='application/json',
)
auth = {'instance_id': create_instance, 'api_id': 1}
api_post(
'/v0/users/{}/authorizations'.format(resp_user['id']),
data=json.dumps(auth),
content_type='application/json',
)
resp = api_get('/v0/users/{}'.format(resp_user['id']))
resp_key = api_delete('/v0/users/{user_id}/keys/{key_id}'.format(
user_id=resp['id'], key_id=resp['keys'][0]['id']))
assert len(resp_key['keys']) == 0
resp_auth = api_delete('/v0/users/{}/authorizations/'.format(resp['id']),
data=json.dumps(auth),
content_type='application/json')
assert len(resp_auth['authorizations']) == 0
assert mock_rabbit.called
def test_health_ok(setup_database):
with requests_mock.mock() as m:
# Connection to navitia and database works
kirin.app.config["NAVITIA_URL"] = "http://navitia"
m.head("http://navitia", status_code=200)
resp = api_get("/health")
assert resp["message"] == "OK"
def test_cots_trip_unknown_vj(mock_rabbitmq):
"""
a trip with a parity has been impacted, but the train 6112 is not known by navitia
there should be only the train 6113 impacted
"""
cots_6113 = get_fixture_data('cots_train_6113_trip_removal.json')
cots_6112 = cots_6113.replace('"numeroCourse": "006113",',
'"numeroCourse": "006112",')
res = api_post('/cots', data=cots_6112, check=False)
assert res[1] == 404
assert res[0]['error'] == 'no train found for headsign(s) 006112'
with app.app_context():
assert len(RealTimeUpdate.query.all()) == 1
assert len(TripUpdate.query.all()) == 0
assert len(StopTimeUpdate.query.all()) == 0
assert RealTimeUpdate.query.first().status == 'KO'
assert RealTimeUpdate.query.first().error == \
'no train found for headsign(s) 006112'
assert RealTimeUpdate.query.first().raw_data == cots_6112
status = api_get('/status')
assert '-' in status['last_update'][
'realtime.cots'] # only check it's a date
assert status['last_valid_update'] == {}
assert status['last_update_error'][
'realtime.cots'] == 'no train found for headsign(s) 006112'
assert mock_rabbitmq.call_count == 0
def test_add_user(mock_rabbit, geojson_polygon):
"""
creation of a user passing arguments as a json
"""
coord = '2.37730;48.84550'
user = {
'login': '******',
'email': '*****@*****.**',
'shape': geojson_polygon,
'has_shape': True,
'default_coord': coord,
}
data = json.dumps(user)
resp = api_post('/v0/users/', data=data, content_type='application/json')
def check(u):
gen = (k for k in user if k != 'shape')
for k in gen:
assert u[k] == user[k]
assert u['end_point']['name'] == 'navitia.io'
assert u['type'] == 'with_free_instances'
assert u['block_until'] is None
check(resp)
assert resp['shape'] == geojson_polygon
assert resp['default_coord'] == coord
assert_default_scop_shape(resp)
resp = api_get('/v0/users/')
assert len(resp) == 1
check(resp[0])
assert resp[0]['shape'] == {}
assert mock_rabbit.called
assert_default_scop_shape(resp[0])
def test_ridesharing_service_get(default_ridesharing_service_config):
"""
Test that the list of services with their info is correctly returned when queried
"""
_, ridesharing0, ridesharing1 = default_ridesharing_service_config
resp = api_get('/v0/ridesharing_services')
assert 'ridesharing_services' in resp
assert len(resp['ridesharing_services']) == 2
resp = api_get('/v0/ridesharing_services/TestCovoiturage0')
assert 'ridesharing_services' in resp
assert len(resp['ridesharing_services']) == 1
assert resp['ridesharing_services'][0]['args'] == ridesharing0.args
assert resp['ridesharing_services'][0]['id'] == ridesharing0.id
assert not resp['ridesharing_services'][0]['discarded']
def test_add_user_with_plus_in_query(mock_rabbit):
"""
creation of a user with a "+" in the email
"""
user = {
'email': '*****@*****.**',
'login': '******'
}
_, status = api_post(
'/v0/users/?login={email}&email={email}'.format(email=user['email']),
check=False)
assert status == 400
resp = api_post('/v0/users/?login={email}&email={email}'.format(
email=urllib.quote(user['email'])))
def check(u):
for k in user.iterkeys():
assert u[k] == user[k]
assert u['end_point']['name'] == 'navitia.io'
assert u['type'] == 'with_free_instances'
assert u['block_until'] is None
check(resp)
resp = api_get('/v0/users/')
assert len(resp) == 1
check(resp[0])
assert mock_rabbit.called
def test_add_user_with_plus(mock_rabbit):
"""
creation of a user with a "+" in the email
"""
user = {
'login': '******',
'email': '*****@*****.**'
}
resp = api_post('/v0/users/',
data=json.dumps(user),
content_type='application/json')
def check(u):
for k in user.iterkeys():
assert u[k] == user[k]
assert u['end_point']['name'] == 'navitia.io'
assert u['type'] == 'with_free_instances'
assert u['block_until'] is None
check(resp)
resp = api_get('/v0/users/')
assert len(resp) == 1
check(resp[0])
assert mock_rabbit.called
def test_status_with_navitia_ko(setup_database):
with requests_mock.mock() as m:
kirin.app.config["NAVITIA_URL"] = "http://navitia_on_error"
m.head("http://navitia_on_error", status_code=400)
resp, _ = api_get("/status", check=False)
assert "url" in resp["navitia_webservice"]
assert resp["navitia_webservice"]["connection"] == "KO"
assert resp["postgres_db"]["connection"] == "OK"
# All the other attributes are present as in the test "test_status()"
assert "version" in resp
assert "pool_status" in resp["postgres_db"]
assert "schema_version" in resp["postgres_db"]
assert "connection" in resp["postgres_db"]
assert "last_update" in resp
assert COTS_CONTRIBUTOR_ID in resp["last_update"]
assert GTFS_CONTRIBUTOR_ID in resp["last_update"]
assert "2015-11-04T07:32:00Z" in resp["last_update"][
COTS_CONTRIBUTOR_ID]
assert "2015-11-04T07:52:00Z" in resp["last_update"][
GTFS_CONTRIBUTOR_ID]
assert GTFS_CONTRIBUTOR_ID in resp["last_update_error"]
assert "2015-11-04T07:32:00Z" in resp["last_valid_update"][
COTS_CONTRIBUTOR_ID]
assert "2015-11-04T07:42:00Z" in resp["last_valid_update"][
GTFS_CONTRIBUTOR_ID]
def test_multiple_users(create_multiple_users, mock_rabbit):
"""
check the list
"""
resp = api_get('/v0/users/')
assert len(resp) == 2
user1_found = False
user2_found = False
for u in resp:
if u['id'] == create_multiple_users['user1']:
user1_found = True
assert u['login'] == 'foo'
assert u['email'] == '*****@*****.**'
assert u['end_point']['name'] == 'myEndPoint'
assert u['billing_plan']['name'] == 'free'
if u['id'] == create_multiple_users['user2']:
user2_found = True
assert u['login'] == 'foodefault'
assert u['email'] == '*****@*****.**'
assert u['end_point']['name'] == 'navitia.io'
assert u['billing_plan']['name'] == 'nav_ctp'
assert user1_found
assert user2_found
assert mock_rabbit.call_count == 0
def test_get_non_existant_profile(create_instance):
"""
by default there is no traveler profile created for an instance
"""
_, status = api_get('/v0/instances/fr/traveler_profiles/standard',
check=False)
assert status == 404
def test_bss_provider_post():
input_json = {'network': 'foo', 'klass': 'jcdecaux', 'args': {'user': '******'}}
def check(resp):
assert resp['network'] == input_json['network']
assert resp['klass'] == input_json['klass']
assert resp['args'] == input_json['args']
assert resp['discarded'] == False
_, status = api_post('v0/bss_providers/',
data=json.dumps(input_json),
content_type='application/json',
check=False)
assert status == 400
resp, status = api_post('v0/bss_providers/foo',
data=json.dumps(input_json),
content_type='application/json',
check=False)
assert status == 201
check(resp)
resp = api_get('v0/bss_providers/foo')
assert 'bss_providers' in resp
assert len(resp['bss_providers']) == 1
check(resp['bss_providers'][0])
def test_update_max_nb_crowfly_by_mode(create_instance):
resp = api_get('/v0/instances/fr')
assert resp[0]['max_nb_crowfly_by_mode']['car'] == 5000
assert resp[0]['max_nb_crowfly_by_mode']['walking'] == 5000
assert resp[0]['max_nb_crowfly_by_mode']['bike'] == 5000
assert resp[0]['max_nb_crowfly_by_mode']['bss'] == 5000
assert resp[0]['max_nb_crowfly_by_mode']['taxi'] == 5000
params = {
"max_nb_crowfly_by_mode": {
'car': 4242,
'walking': 4141,
'taxi': 2323
}
}
resp, status = api_put('/v0/instances/fr',
data=json.dumps(params),
check=False,
content_type='application/json')
assert status == 200
assert resp['max_nb_crowfly_by_mode']['car'] == 4242
assert resp['max_nb_crowfly_by_mode']['walking'] == 4141
assert resp['max_nb_crowfly_by_mode']['bike'] == 5000
assert resp['max_nb_crowfly_by_mode']['bss'] == 5000
assert resp['max_nb_crowfly_by_mode']['taxi'] == 2323
def test_get_instance_with_traveler_profile(create_instance):
resp = api_get('/v0/instances/fr')
assert len(resp) == 1
assert 'traveler_profiles' in resp[0]
assert len(
resp[0]
['traveler_profiles']) == 0, "By default, traveler profiles are empty"
def test_users_methods():
user_data = {'login': '******', 'email': '*****@*****.**'}
resp_post = api_post('/v1/users',
data=json.dumps(user_data),
content_type='application/json')
assert 'user' in resp_post
assert resp_post['user']['login'] == 'user1'
assert resp_post['user']['email'] == '*****@*****.**'
user_id = resp_post['user']['id']
user_data_update = {'type': 'super_user'}
resp_put = api_put('/v1/users/{}'.format(user_id),
data=json.dumps(user_data_update),
content_type='application/json')
assert 'user' in resp_put
assert resp_put['user']['login'] == 'user1'
assert resp_put['user']['type'] == 'super_user'
resp_delete, status_delete = api_delete('/v1/users/{}'.format(user_id),
check=False,
no_json=True)
assert status_delete == 204
resp_get, status_get = api_get('/v1/users/{}'.format(user_id), check=False)
assert status_get == 404
def test_status_ok():
"""
Test that the endpoint '/status' returns the db version
"""
resp = api_get('/v0/status/')
assert 'db version' in resp
assert resp['db version'] is not None
def test_equipments_provider_get(default_config):
"""
Test that the list of providers with their info is correctly returned when queried
"""
sytral_provider, sytral2_provider = default_config
resp = api_get('/v0/equipments_providers')
assert 'equipments_providers' in resp
assert len(resp['equipments_providers']) == 2
resp = api_get('/v0/equipments_providers/sytral')
assert 'equipments_providers' in resp
assert len(resp['equipments_providers']) == 1
assert len(resp['equipments_providers'][0]['instances']) == 1
assert resp['equipments_providers'][0]['instances'][0] == 'sytral_instance'
assert resp['equipments_providers'][0]['args'] == sytral_provider.args
assert not resp['equipments_providers'][0]['discarded']
def test_ridesharing_service_put(default_ridesharing_service_config):
"""
Test that a service is correctly created/updated in db and the info returned when queried
"""
service = {
'klass':
'jormungandr.scenarios.ridesharing.instant_system.InstantSystem',
'args': {
'service_url': 'https://new_url.io',
"rating_scale_min": 5,
"crowfly_radius": 60,
"api_key": "abcd",
},
}
resp, status = api_put(
'v0/ridesharing_services/TestCovoiturage3',
data=ujson.dumps(service),
content_type='application/json',
check=False,
)
assert status == 201
assert 'ridesharing_services' in resp
assert len(resp['ridesharing_services']) == 1
for key in service.keys():
assert resp['ridesharing_services'][0][key] == service[key]
resp = api_get('/v0/ridesharing_services')
assert 'ridesharing_services' in resp
assert len(resp['ridesharing_services']) == 3
# Update existing service
service['args']['service_url'] = 'https://new_url_update.io'
resp = api_put('v0/ridesharing_services/TestCovoiturage3',
data=ujson.dumps(service),
content_type='application/json')
assert 'ridesharing_services' in resp
assert len(resp['ridesharing_services']) == 1
for key in service.keys():
assert resp['ridesharing_services'][0][key] == service[key]
resp = api_get('/v0/ridesharing_services/TestCovoiturage3')
assert 'ridesharing_services' in resp
assert len(resp['ridesharing_services']) == 1
assert resp['ridesharing_services'][0]['args'][
'service_url'] == 'https://new_url_update.io'
def test_delete_traveler_profile(create_instance):
api_post('/v0/instances/fr/traveler_profiles/standard')
_, status = api_delete('/v0/instances/fr/traveler_profiles/standard', check=False, no_json=True)
assert status == 204
_, status = api_get('/v0/instances/fr/traveler_profiles/standard', check=False)
assert status == 404
def test_filter_users_by_key(create_user, create_multiple_users):
resp_users = api_get('/v0/users')
assert len(resp_users) == 3
for user in resp_users:
api_post(
'/v0/users/{}/keys'.format(user['id']),
data=json.dumps({'app_name': 'myApp'}),
content_type='application/json',
)
resp_user = api_get('/v0/users/{}'.format(user['id']))
assert len(resp_user['keys']) == 1
assert 'token' in resp_user['keys'][0]
token = resp_user['keys'][0]['token']
resp_token = api_get('/v0/users?key={}'.format(token))
assert resp_token['id'] == user['id']
def test_create_traveler_profile(create_instance, traveler_profile_params):
resp = api_post('/v0/instances/fr/traveler_profiles/standard',
data=json.dumps(traveler_profile_params),
content_type='application/json')
check_traveler_profile(resp, traveler_profile_params)
resp = api_get('/v0/instances/fr/traveler_profiles/standard')
check_traveler_profile(resp[0], traveler_profile_params)
def test_wrong_get_piv_with_id():
"""
GET /piv/id.contributor (so with an id) is not allowed, only POST is possible
"""
resp, status = api_get("/piv/{}".format(PIV_CONTRIBUTOR_ID), check=False)
assert status == 405
assert resp.get(
"message") == "The method is not allowed for the requested URL."
def test_associate_instance_external_service(default_external_service_config):
instance, external_service_1, external_service_2 = default_external_service_config
# Associate one external service
resp = api_put('/v1/instances/{}?external_services={}'.format(
instance.name, external_service_1.id))
assert len(resp["external_services"]) == 1
assert resp["external_services"][0]["id"] == external_service_1.id
# Check that instance contains only one external service
resp = api_get('/v1/instances')
assert len(resp['instances']) == 1
assert len(resp['instances'][0]['external_services']) == 1
assert resp['instances'][0]['external_services'][0][
'id'] == external_service_1.id
# Update associated external service by external_service_2
resp = api_put('/v1/instances/{}?external_services={}'.format(
instance.name, external_service_2.id))
assert len(resp["external_services"]) == 1
assert resp["external_services"][0]["id"] == external_service_2.id
# Check that instance contains only one external service
resp = api_get('/v1/instances')
assert len(resp['instances']) == 1
assert len(resp['instances'][0]['external_services']) == 1
# Associate two external services to the same instance
resp = api_put(
'/v1/instances/{}?external_services={}&external_services={}'.format(
instance.name, external_service_1.id, external_service_2.id))
assert len(resp["external_services"]) == 2
# An update with one external service deletes all existing associations and
# re associates this external service to the instance
resp = api_put('/v1/instances/{}?external_services={}'.format(
instance.name, external_service_1.id))
assert len(resp["external_services"]) == 1
assert resp["external_services"][0]["id"] == external_service_1.id
# Check that instance contains only one external service
resp = api_get('/v1/instances')
assert len(resp['instances']) == 1
assert len(resp['instances'][0]['external_services']) == 1
assert resp['instances'][0]['external_services'][0][
'id'] == external_service_1.id
def test_index_ok():
"""
Test that the endpoint '/' returns a list of endpoints with their url
"""
resp = api_get('/')
assert resp is not None
for endpoint in resp.keys():
assert 'href' in resp[endpoint]
def test_add_user_without_shape(mock_rabbit):
"""
creation of a user without shape
When we get this user, we should see
shape = None and has_shape = False
"""
user = {'login': '******', 'email': '*****@*****.**'}
data = json.dumps(user)
resp = api_post('/v0/users/', data=data, content_type='application/json')
def check(u):
gen = (k for k in user if k != 'shape')
for k in gen:
assert u[k] == user[k]
assert u['end_point']['name'] == 'navitia.io'
assert u['type'] == 'with_free_instances'
assert u['block_until'] is None
# User created but not modified yet
assert u['created_at'] is not None
assert u['updated_at'] is None
assert u['blocked_at'] is None
check(resp)
assert resp['shape'] is None
assert resp['has_shape'] is False
assert mock_rabbit.called
assert_default_scop_shape(resp)
# we did not give any coord, so we don't have some
assert resp['default_coord'] is None
# with disable_geojson=true by default
resp = api_get('/v0/users/')
assert len(resp) == 1
check(resp[0])
assert resp[0]['shape'] is None
assert resp[0]['has_shape'] is False
assert_default_scop_shape(resp[0])
# with disable_geojson=false
resp = api_get('/v0/users/?disable_geojson=false')
assert len(resp) == 1
check(resp[0])
assert resp[0]['shape'] is None
assert resp[0]['has_shape'] is False
assert_default_scop_shape(resp[0])
def test_status(setup_database):
resp = api_get('/status')
assert 'version' in resp
assert 'db_pool_status' in resp
assert 'db_version' in resp
assert 'navitia_url' in resp
assert 'last_update' in resp
assert 'realtime.ire' in resp['last_update']
assert 'realtime.timeo' in resp['last_update']
assert '2015-11-04T07:32:00Z' in resp['last_update']['realtime.ire']
assert '2015-11-04T07:42:00Z' in resp['last_update']['realtime.timeo']
def test_end_point():
resp = api_get('/')
assert 'status' in resp
assert 'ire' in resp
