diff options
Diffstat (limited to 'moon_engine/tests/unit_python/api/pipeline/test_update.py')
| -rw-r--r-- | moon_engine/tests/unit_python/api/pipeline/test_update.py | 525 |
1 files changed, 525 insertions, 0 deletions
diff --git a/moon_engine/tests/unit_python/api/pipeline/test_update.py b/moon_engine/tests/unit_python/api/pipeline/test_update.py new file mode 100644 index 00000000..94d5a4e4 --- /dev/null +++ b/moon_engine/tests/unit_python/api/pipeline/test_update.py @@ -0,0 +1,525 @@ +# Software Name: MOON + +# Version: 5.4 + +# SPDX-FileCopyrightText: Copyright (c) 2018-2020 Orange and its contributors +# SPDX-License-Identifier: Apache-2.0 + +# This software is distributed under the 'Apache License 2.0', +# the text of which is available at 'http://www.apache.org/licenses/LICENSE-2.0.txt' +# or see the "LICENSE" file for more details. + + +import hug +import requests +from uuid import uuid4 + + +def test_pipeline_update_policy_existed(): + from moon_engine.api.pipeline import update + from moon_utilities.auth_functions import get_api_key_for_user + from moon_engine.api.configuration import get_configuration + + auth_headers = {"X-Api-Key": get_api_key_for_user("admin")} + + response = requests.get("{}/policies".format(get_configuration("management").get("url")), + headers=auth_headers) + + policies = response.json() + key = next(iter(policies['policies'])) + policies['policies'][key]['name'] = "new " + policies['policies'][key]['name'] + req = hug.test.put(update, "/update/policy/{}".format(key), + policies['policies'][key], headers=auth_headers) + assert req.status == hug.HTTP_208 + + +def test_pipeline_update_policy_not_existed(): + from moon_engine.api.pipeline import update + from moon_utilities.auth_functions import get_api_key_for_user + from moon_engine.api.configuration import get_configuration + + auth_headers = {"X-Api-Key": get_api_key_for_user("admin")} + + response = requests.get("{}/policies".format(get_configuration("management").get("url")), + headers=auth_headers) + + policies = response.json() + key = next(iter(policies['policies'])) + policies['policies'][key]['name'] = "new " + policies['policies'][key]['name'] + req = hug.test.put(update, "/update/policy/{}".format(uuid4().hex), + policies['policies'][key], headers=auth_headers) + assert req.status == hug.HTTP_208 + + +def test_pipeline_delete_policy(): + from moon_engine.api.pipeline import update + from moon_utilities.auth_functions import get_api_key_for_user + from moon_engine.api.configuration import get_configuration + + auth_headers = {"X-Api-Key": get_api_key_for_user("admin")} + + response = requests.get("{}/policies".format(get_configuration("management").get("url")), + headers=auth_headers) + policies = response.json() + key = next(iter(policies['policies'])) + req = hug.test.delete(update, "/update/policy/{}".format(key), + headers=auth_headers) + assert req.status == hug.HTTP_202 + + +def test_pipeline_update_pdp_existed(): + from moon_engine.api.pipeline import update + from moon_utilities.auth_functions import get_api_key_for_user + from moon_engine.api.configuration import get_configuration + + auth_headers = {"X-Api-Key": get_api_key_for_user("admin")} + + response = requests.get("{}/pdp".format(get_configuration("management").get("url")), + headers=auth_headers) + + pdps = response.json() + key = next(iter(pdps['pdps'])) + pdps['pdps'][key]['name'] = "new " + pdps['pdps'][key]['name'] + req = hug.test.put(update, "/update/pdp/{}".format(key), + pdps['pdps'][key], headers=auth_headers) + assert req.status == hug.HTTP_208 + + +def test_pipeline_update_pdp_not_existed(): + from moon_engine.api.pipeline import update + from moon_utilities.auth_functions import get_api_key_for_user + from moon_engine.api.configuration import get_configuration + + auth_headers = {"X-Api-Key": get_api_key_for_user("admin")} + + response = requests.get("{}/pdp".format(get_configuration("management").get("url")), + headers=auth_headers) + + pdps = response.json() + key = next(iter(pdps['pdps'])) + pdps['pdps'][key]['name'] = "new " + pdps['pdps'][key]['name'] + req = hug.test.put(update, "/update/pdp/{}".format(uuid4().hex), + pdps['pdps'][key], headers=auth_headers) + assert req.status == hug.HTTP_208 + + +def test_pipeline_delete_pdp_existed(): + from moon_engine.api.pipeline import update + from moon_utilities.auth_functions import get_api_key_for_user + from moon_engine.api.configuration import get_configuration + + auth_headers = {"X-Api-Key": get_api_key_for_user("admin")} + + response = requests.get("{}/pdp".format(get_configuration("management").get("url")), + headers=auth_headers) + + pdps = response.json() + key = next(iter(pdps['pdps'])) + req = hug.test.delete(update, "/update/pdp/{}".format(key), headers=auth_headers) + assert req.status == hug.HTTP_202 + + +def test_pipeline_update_perimeter_existed(): + from moon_engine.api.pipeline import update + from moon_utilities.auth_functions import get_api_key_for_user + from moon_engine.api.configuration import get_configuration + + auth_headers = {"X-Api-Key": get_api_key_for_user("admin")} + + response = requests.get("{}/policies".format(get_configuration("management").get("url")), + headers=auth_headers) + + policies = response.json() + policy_key = next(iter(policies['policies'])) + + subject_response = requests.get("{}/policies/{}/subjects".format(get_configuration( + "management").get("url"), policy_key), headers=auth_headers) + subjects = subject_response.json() + subj_key = next(iter(subjects['subjects'])) + subjects['subjects'][subj_key]['name'] = "updated_" + subjects['subjects'][subj_key]['name'] + + subject_req = hug.test.put(update, "/update/perimeter/{}/{}/{}".format(subj_key, policy_key, + "subject"), + subjects['subjects'][subj_key], headers=auth_headers) + assert subject_req.status == hug.HTTP_208 + + """ object category """ + object_response = requests.get("{}/policies/{}/objects".format(get_configuration( + "management").get("url"), policy_key), headers=auth_headers) + objects = object_response.json() + obj_key = next(iter(objects['objects'])) + objects['objects'][obj_key]['name'] = "updated_" + objects['objects'][obj_key]['name'] + + object_req = hug.test.put(update, "/update/perimeter/{}/{}/{}".format(obj_key, policy_key, "object") + , objects['objects'][obj_key], headers=auth_headers) + assert object_req.status == hug.HTTP_208 + + """ action category """ + action_response = requests.get("{}/policies/{}/actions".format(get_configuration( + "management").get("url"), policy_key), headers=auth_headers) + actions = action_response.json() + action_key = next(iter(actions['actions'])) + actions['actions'][action_key]['name'] = "updated_" + actions['actions'][action_key]['name'] + + action_req = hug.test.put(update, "/update/perimeter/{}/{}/{}".format(action_key, policy_key, + "action"), + actions['actions'][action_key], headers=auth_headers) + assert action_req.status == hug.HTTP_208 + + +def test_pipeline_update_perimeter_not_existed(): + from moon_engine.api.pipeline import update + from moon_utilities.auth_functions import get_api_key_for_user + from moon_engine.api.configuration import get_configuration + + auth_headers = {"X-Api-Key": get_api_key_for_user("admin")} + + response = requests.get("{}/policies".format(get_configuration("management").get("url")), + headers=auth_headers) + + policies = response.json() + policy_key = next(iter(policies['policies'])) + + subject_response = requests.get("{}/policies/{}/subjects".format(get_configuration( + "management").get("url"), policy_key), headers=auth_headers) + subjects = subject_response.json() + subj_key = next(iter(subjects['subjects'])) + subjects['subjects'][subj_key]['name'] = "updated_" + subjects['subjects'][subj_key]['name'] + + subject_req = hug.test.put(update, "/update/perimeter/{}/{}/{}".format(uuid4().hex, policy_key, + "subject"), + subjects['subjects'][subj_key], headers=auth_headers) + assert subject_req.status == hug.HTTP_208 + + """ object category """ + object_response = requests.get("{}/policies/{}/objects".format(get_configuration( + "management").get("url"), policy_key), headers=auth_headers) + objects = object_response.json() + obj_key = next(iter(objects['objects'])) + objects['objects'][obj_key]['name'] = "updated_" + objects['objects'][obj_key]['name'] + + object_req = hug.test.put(update, "/update/perimeter/{}/{}/{}".format(uuid4().hex, policy_key, "object") + , objects['objects'][obj_key], headers=auth_headers) + assert object_req.status == hug.HTTP_208 + + """ action category """ + action_response = requests.get("{}/policies/{}/actions".format(get_configuration( + "management").get("url"), policy_key), headers=auth_headers) + actions = action_response.json() + action_key = next(iter(actions['actions'])) + actions['actions'][action_key]['name'] = "updated_" + actions['actions'][action_key]['name'] + + action_req = hug.test.put(update, "/update/perimeter/{}/{}/{}".format(uuid4().hex, policy_key, + "action"), + actions['actions'][action_key], headers=auth_headers) + assert action_req.status == hug.HTTP_208 + + +def test_pipeline_delete_perimeter_existed(): + from moon_engine.api.pipeline import update + from moon_utilities.auth_functions import get_api_key_for_user + from moon_engine.api.configuration import get_configuration + + auth_headers = {"X-Api-Key": get_api_key_for_user("admin")} + + policies_response = requests.get("{}/policies".format(get_configuration("management").get("url")), + headers=auth_headers) + + policies = policies_response.json() + policy_key = next(iter(policies['policies'])) + + subject_response = requests.get("{}/policies/{}/subjects".format(get_configuration( + "management").get("url"), policy_key), headers=auth_headers) + subjects = subject_response.json() + subj_key = next(iter(subjects['subjects'])) + subjects['subjects'][subj_key]['name'] = "updated_" + subjects['subjects'][subj_key]['name'] + + delete_subject_response = hug.test.delete(update, "/update/perimeter/{}/{}/{}".format(subj_key, policy_key, + "subject"), + headers=auth_headers) + assert delete_subject_response.status == hug.HTTP_202 + + object_response = requests.get("{}/policies/{}/objects".format(get_configuration( + "management").get("url"), policy_key), headers=auth_headers) + objects = object_response.json() + assert 'objects' in objects and len(objects['objects']) + + for key in objects['objects']: + delete_object_response = hug.test.delete(update, "/update/perimeter/{}/{}/{}".format(key, policy_key, 'object'), + headers=auth_headers) + assert delete_object_response.status == hug.HTTP_202 + + action_response = requests.get("{}/policies/{}/actions".format(get_configuration( + "management").get("url"), policy_key), headers=auth_headers) + actions = action_response.json() + assert 'actions' in actions and len(actions['actions']) + + for key in actions['actions']: + delete_action_response = hug.test.delete(update, "/update/perimeter/{}/{}/{}".format(key, policy_key, 'action'), + headers=auth_headers) + assert delete_action_response.status == hug.HTTP_202 + + +def test_pipeline_delete_assignments(): + from moon_engine.api.pipeline import update + from moon_utilities.auth_functions import get_api_key_for_user + from moon_engine.api.configuration import get_configuration + + auth_headers = {"X-Api-Key": get_api_key_for_user("admin")} + + response = requests.get("{}/policies".format(get_configuration("management").get("url")), + headers=auth_headers) + policies = response.json() + policy_id = next(iter(policies['policies'])) + + sub_assig_response = requests.get("{}/policies/{}/subject_assignments".format(get_configuration("management").get("url"), + policy_id), headers=auth_headers) + + subject_assignments = sub_assig_response.json() + assert 'subject_assignments' in subject_assignments and len( + subject_assignments['subject_assignments']) + req = hug.test.delete(update, + "/update/assignment/{}/{}/".format(policy_id, "subject"), + headers=auth_headers) + assert req.status == hug.HTTP_202 + + obj_assig_response = requests.get("{}/policies/{}/object_assignments".format(get_configuration( + "management").get("url"), policy_id), + headers=auth_headers) + object_assignments = obj_assig_response.json() + assert 'object_assignments' in object_assignments and len( + object_assignments['object_assignments']) + req = hug.test.delete(update, + "/update/assignment/{}/{}/".format(policy_id, "object"), + headers=auth_headers) + assert req.status == hug.HTTP_202 + + action_assig_response = requests.get("{}/policies/{}/action_assignments".format(get_configuration( + "management").get("url"), policy_id), + headers=auth_headers) + action_assignments = action_assig_response.json() + assert 'action_assignments' in action_assignments and len( + action_assignments['action_assignments']) + req = hug.test.delete(update, + "/update/assignment/{}/{}/".format(policy_id, "action"), + headers=auth_headers) + assert req.status == hug.HTTP_202 + + +def test_pipeline_delete_rule(): + from moon_engine.api.pipeline import update + from moon_utilities.auth_functions import get_api_key_for_user + from moon_engine.api.configuration import get_configuration + + auth_headers = {"X-Api-Key": get_api_key_for_user("admin")} + + policy_response = requests.get("{}/policies".format(get_configuration("management").get("url")), + headers=auth_headers) + policies = policy_response.json() + policy_id = next(iter(policies['policies'])) + + rules_response = requests.get( + "{}/policies/{}/rules".format(get_configuration("management").get("url"), policy_id), + headers=auth_headers) + rules = rules_response.json() + + assert len(rules['rules']['rules']) + for i in range(0, len(rules['rules']['rules'])): + req = hug.test.delete(update, "/update/rule/{}/{}".format(policy_id, rules['rules'][ + 'rules'][i]['id']), headers=auth_headers) + assert req.status == hug.HTTP_202 + + +def test_pipeline_update_model_existed(): + from moon_engine.api.pipeline import update + from moon_utilities.auth_functions import get_api_key_for_user + from moon_engine.api.configuration import get_configuration + + auth_headers = {"X-Api-Key": get_api_key_for_user("admin")} + + model_response = requests.get("{}/models".format(get_configuration("management").get("url")), + headers=auth_headers) + + models = model_response.json() + key = next(iter(models['models'])) + models['models'][key]['name'] = "new " + models['models'][key]['name'] + req = hug.test.put(update, "/update/model/{}".format(key), + models['models'][key], headers=auth_headers) + assert req.status == hug.HTTP_208 + + +def test_pipeline_update_model_not_existed(): + from moon_engine.api.pipeline import update + from moon_utilities.auth_functions import get_api_key_for_user + from moon_engine.api.configuration import get_configuration + + auth_headers = {"X-Api-Key": get_api_key_for_user("admin")} + + model_response = requests.get("{}/models".format(get_configuration("management").get("url")), + headers=auth_headers) + + models = model_response.json() + key = next(iter(models['models'])) + models['models'][key]['name'] = "new " + models['models'][key]['name'] + req = hug.test.put(update, "/update/model/{}".format(uuid4().hex), + models['models'][key], headers=auth_headers) + assert req.status == hug.HTTP_208 + + +def test_pipeline_delete_model_existed(): + from moon_engine.api.pipeline import update + from moon_utilities.auth_functions import get_api_key_for_user + from moon_engine.api.configuration import get_configuration + + auth_headers = {"X-Api-Key": get_api_key_for_user("admin")} + + model_response = requests.get("{}/models".format(get_configuration("management").get("url")), + headers=auth_headers) + + models = model_response.json() + key = next(iter(models['models'])) + req = hug.test.delete(update, "/update/model/{}".format(key), headers=auth_headers) + assert req.status == hug.HTTP_202 + + +def test_pipeline_delete_category(): + from moon_engine.api.pipeline import update + from moon_utilities.auth_functions import get_api_key_for_user + from moon_engine.api.configuration import get_configuration + + auth_headers = {"X-Api-Key": get_api_key_for_user("admin")} + + subject_cat_response = requests.get("{}/subject_categories".format(get_configuration( + "management").get("url")), headers=auth_headers) + subject_categories = subject_cat_response.json() + category_id = next(iter(subject_categories['subject_categories'])) + req = hug.test.delete(update, "/update/meta_data/{}/{}".format(category_id, 'subject'), + headers=auth_headers) + assert req.status == hug.HTTP_202 + + action_cat_response = requests.get("{}/action_categories".format(get_configuration( + "management").get("url")), + headers=auth_headers) + action_categories = action_cat_response.json() + category_id = next(iter(action_categories['action_categories'])) + req = hug.test.delete(update, "/update/meta_data/{}/{}".format(category_id, 'action'), + headers=auth_headers) + assert req.status == hug.HTTP_202 + + obj_cat_response = requests.get("{}/object_categories".format(get_configuration( + "management").get("url")), + headers=auth_headers) + object_categories = obj_cat_response.json() + category_id = next(iter(object_categories['object_categories'])) + req = hug.test.delete(update, "/update/meta_data/{}/{}".format(category_id, 'object'), + headers=auth_headers) + assert req.status == hug.HTTP_202 + + +def test_pipeline_update_meta_rule_existed(): + from moon_engine.api.pipeline import update + from moon_utilities.auth_functions import get_api_key_for_user + from moon_engine.api.configuration import get_configuration + + auth_headers = {"X-Api-Key": get_api_key_for_user("admin")} + + meta_rules_response = requests.get("{}/meta_rules".format(get_configuration("management").get("url")), + headers=auth_headers) + + meta_rules = meta_rules_response.json() + key = next(iter(meta_rules['meta_rules'])) + meta_rules['meta_rules'][key]['name'] = "new " + meta_rules['meta_rules'][key]['name'] + req = hug.test.put(update, "/update/meta_rule/{}".format(key), + meta_rules['meta_rules'][key], headers=auth_headers) + assert req.status == hug.HTTP_208 + + +def test_pipeline_update_meta_rule_not_existed(): + from moon_engine.api.pipeline import update + from moon_utilities.auth_functions import get_api_key_for_user + from moon_engine.api.configuration import get_configuration + + auth_headers = {"X-Api-Key": get_api_key_for_user("admin")} + + meta_rules_response = requests.get("{}/meta_rules".format(get_configuration("management").get("url")), + headers=auth_headers) + + meta_rules = meta_rules_response.json() + key = next(iter(meta_rules['meta_rules'])) + meta_rules['meta_rules'][key]['name'] = "new " + meta_rules['meta_rules'][key]['name'] + req = hug.test.put(update, "/update/meta_rule/{}".format(uuid4().hex), + meta_rules['meta_rules'][key], headers=auth_headers) + assert req.status == hug.HTTP_208 + + +def test_pipeline_delete_meta_rule(): + from moon_engine.api.pipeline import update + from moon_utilities.auth_functions import get_api_key_for_user + from moon_engine.api.configuration import get_configuration + + auth_headers = {"X-Api-Key": get_api_key_for_user("admin")} + + meta_rules_response = requests.get("{}/meta_rules".format(get_configuration("management").get("url")), + headers=auth_headers) + + meta_rules = meta_rules_response.json() + key = next(iter(meta_rules['meta_rules'])) + req = hug.test.delete(update, "/update/meta_rule/{}".format(key), headers=auth_headers) + assert req.status == hug.HTTP_202 + + +def test_pipeline_delete_data(): + from moon_engine.api.pipeline import update + from moon_utilities.auth_functions import get_api_key_for_user + from moon_engine.api.configuration import get_configuration + + auth_headers = {"X-Api-Key": get_api_key_for_user("admin")} + + policies_response = requests.get("{}/policies".format(get_configuration("management").get("url")), + headers=auth_headers) + + policies = policies_response.json() + policy_id = next(iter(policies['policies'])) + + subject_data_response = requests.get( + "{}/policies/{}/subject_data".format(get_configuration("management").get("url"), policy_id), + headers=auth_headers) + subject_data_id = next(iter(subject_data_response.json()['subject_data'][0]['data'])) + delete_subject_data_response = hug.test.delete(update, "/update/data/{}/{}".format(subject_data_id, 'subject'), + headers=auth_headers) + assert delete_subject_data_response.status == hug.HTTP_202 + + object_data_response = requests.get( + "{}/policies/{}/object_data".format(get_configuration("management").get("url"), policy_id), + headers=auth_headers) + object_data_id = next(iter(object_data_response.json()['object_data'][0]['data'])) + delete_object_data_response = hug.test.delete(update, "/update/data/{}/{}".format(object_data_id, 'object'), + headers=auth_headers) + assert delete_object_data_response.status == hug.HTTP_202 + + action_data_response = requests.get( + "{}/policies/{}/action_data".format(get_configuration("management").get("url"), policy_id), + headers=auth_headers) + action_data_id = next(iter(action_data_response.json()['action_data'][0]['data'])) + delete_action_data_response = hug.test.delete(update, "/update/data/{}/{}".format(action_data_id, 'action'), + headers=auth_headers) + assert delete_action_data_response.status == hug.HTTP_202 + + +# def test_pipeline_delete_attributes(): +# from moon_engine.api.pipeline import update +# from moon_utilities.auth_functions import get_api_key_for_user +# from moon_engine.api.configuration import get_configuration +# +# auth_headers = {"X-Api-Key": get_api_key_for_user("admin")} +# +# attributes_response = requests.get( +# "{}/attributes".format(get_configuration("management").get("url")), +# headers=auth_headers) +# +# attributes = attributes_response.json() +# key = next(iter(attributes['attributes'])) +# req = hug.test.delete(update, "/update/attributes/{}".format(key), headers=auth_headers) +# assert req.status == hug.HTTP_202 + + |