From bfdce8fd3b355e5c037326b2bbb5d3c535639220 Mon Sep 17 00:00:00 2001 From: samuelfsd Date: Wed, 27 Sep 2023 23:15:39 -0300 Subject: [PATCH 01/11] feature: first steps understanding async mode --- app/api/asynchronus/functions.py | 88 ++++++++++++++++ app/api/core_api.py | 152 +++++----------------------- app/api/synchronous/functions.py | 166 +++++++++++++++++++++++++++++++ app/util/config_manager.py | 9 +- 4 files changed, 284 insertions(+), 131 deletions(-) create mode 100644 app/api/asynchronus/functions.py create mode 100644 app/api/synchronous/functions.py diff --git a/app/api/asynchronus/functions.py b/app/api/asynchronus/functions.py new file mode 100644 index 0000000..0f773f3 --- /dev/null +++ b/app/api/asynchronus/functions.py @@ -0,0 +1,88 @@ +import json +import os +import configparser + +from flask import ( + Blueprint, + Flask, + jsonify, + render_template, + send_file, + abort, + request, + make_response, +) +from web3 import Web3 + +from dark import DarkMap, DarkGateway +from util.validation import ValidationUtil +from util.config_manager import ConfigManager + +# configurando classe das váriaveis externas +config_manager = ConfigManager() + +## +# configuring dARK GW +## + +bc_config = configparser.ConfigParser() +deployed_contracts_config = configparser.ConfigParser() + +# bc configuration +PROJECT_ROOT = "./" +bc_config.read(os.path.join(PROJECT_ROOT, "config.ini")) +# deployed contracts config +deployed_contracts_config.read(os.path.join(PROJECT_ROOT, "deployed_contracts.ini")) + + +# gw +dark_gw = DarkGateway(bc_config, deployed_contracts_config) + +# +dark_map = DarkMap(dark_gw) + +### +### methods +### + + +# Set the external variable -> config_manager.set_url_validation("BASIC") +async def add_url(ark_id, external_url): + try: + VERIFICATION_METHOD = config_manager.get_url_validation() + except: + VERIFICATION_METHOD = None + + try: + pid = None + if ark_id.startswith("0x"): + pid = dark_map.get_pid_by_hash(ark_id) + else: + pid = dark_map.get_pid_by_ark(ark_id) + + if VERIFICATION_METHOD == "BASIC": + if ValidationUtil.check_url(external_url) == False: + return make_response(jsonify({"error": "Invalid URL"}), 400) + elif VERIFICATION_METHOD == "NONE" or VERIFICATION_METHOD == None: + if len(external_url) == 0: + return make_response(jsonify({"error": "Invalid URL"}), 400) + else: + return make_response( + jsonify({"error": "the method could not be implemented"}), 400 + ) + + tx_set = dark_map.async_set_url(pid.pid_hash, external_url) + tx_status = dark_gw.transaction_was_executed(tx_set) + + result = { + "pid": str(pid.ark), + "pid_hash_index": str(pid.__hash__), + "action": "add_url", + "parameter": external_url, + "transaction_hash": tx_status, + } + + return result, 200 + + except Exception as e: + return make_response(jsonify({"error": str(e)}), 400) diff --git a/app/api/core_api.py b/app/api/core_api.py index 2b0c025..5f9c812 100644 --- a/app/api/core_api.py +++ b/app/api/core_api.py @@ -1,19 +1,28 @@ import json import os import configparser +import asyncio from flask import Blueprint, Flask, jsonify, render_template, send_file, abort, request from web3 import Web3 + from dark import DarkMap, DarkGateway from util.validation import ValidationUtil from util.config_manager import ConfigManager + # configurando classe das váriaveis externas config_manager = ConfigManager() core_api_blueprint = Blueprint("core_api", __name__, url_prefix="/core") +async_mode = config_manager.get_operation_mode() + +from .synchronous.functions import add_url, add_external_pid, set_payload +from .asynchronus.functions import add_url + + ## # configuring dARK GW ## @@ -134,136 +143,10 @@ def get_pid_by_noid(nam, shoulder): return get_pid(dark_id) -# Set the external variable config_manager.set_url_validation("BASIC") -def add_url(ark_id, external_url): - try: - VERIFICATION_METHOD = config_manager.get_url_validation() - except: - VERIFICATION_METHOD = None - - try: - pid = None - if ark_id.startswith("0x"): - pid = dark_map.get_pid_by_hash(ark_id) - else: - pid = dark_map.get_pid_by_ark(ark_id) - - if VERIFICATION_METHOD == "BASIC": - if ValidationUtil.check_url(external_url) == False: - return jsonify({"error": "Invalid URL"}), 400 - elif VERIFICATION_METHOD == "NONE" or VERIFICATION_METHOD == None: - if len(external_url) == 0: - return jsonify({"error": "Invalid URL"}), 400 - else: - return jsonify({"error": "the method could not be implemented"}), 400 - - dark_map.sync_set_url(pid.pid_hash, external_url) - - return ( - jsonify( - { - "pid": str(pid.ark), - "action": "external_url_add", - "parameter": external_url, - } - ), - 200, - ) - - except Exception as e: - return jsonify({"error": str(e)}), 400 - - -# Set the external variable config_manager.set_external_pid_validation("BASIC") -def add_external_pid(ark_id, external_pid): - try: - VERIFICATION_METHOD = config_manager.get_external_pid_validation() - - except: - VERIFICATION_METHOD = None - - try: - pid = None - - if ark_id.startswith("0x"): - pid = dark_map.get_pid_by_hash(ark_id) - else: - pid = dark_map.get_pid_by_ark(ark_id) - - if VERIFICATION_METHOD == "BASIC": - if external_pid.startswith("doi:/") == False: - return jsonify({"error": "Invalid Pid"}), 400 - - elif VERIFICATION_METHOD == "NONE" or VERIFICATION_METHOD == None: - if len(external_pid) == 0: - return jsonify({"error": "Invalid Pid"}), 400 - else: - return jsonify({"error": "the method could not be implemented"}), 400 - - valid_pid = external_pid.split(":/")[1] - dark_map.sync_add_external_pid(pid.pid_hash, valid_pid) - - return ( - jsonify( - { - "pid": str(pid.ark), - "action": "external_pid_add", - "parameter": valid_pid, - } - ), - 200, - ) - - except Exception as e: - return jsonify({"error": str(e)}), 400 - - -# Set the external variable config_manager.set_payload_validation("BASIC") -def set_payload(ark_id, payload): - try: - VERIFICATION_METHOD = config_manager.get_payload_validation() - - except: - VERIFICATION_METHOD = None - - try: - if VERIFICATION_METHOD == "BASIC": - payload = json.loads(payload) - - if type(payload) != dict or len(payload) == 0: - return jsonify({"error": "Invalid JSON payload"}), 400 - - elif VERIFICATION_METHOD == "NONE" or VERIFICATION_METHOD == None: - if type(payload) != dict or len(payload) == 0: - return jsonify({"error": "Invalid JSON payload"}), 400 - else: - return jsonify({"error": "the method could not be implemented"}), 400 - - if ark_id.startswith("0x"): - pid = dark_map.get_pid_by_hash(ark_id) - else: - pid = dark_map.get_pid_by_ark(ark_id) - - dark_map.sync_set_payload(pid.pid_hash, payload) - - return ( - jsonify( - { - "pid": str(pid.ark), - "action": "payload_add", - "parameter": payload, - } - ), - 200, - ) - - except Exception as e: - return jsonify({"error": str(e)}), 400 - - @core_api_blueprint.post("/set/") def set_general(ark_id): if request.is_json: + print(async_mode) data = request.get_json() if len(data) == 0: return jsonify({"error": "No parameter has been passed"}), 405 @@ -280,7 +163,11 @@ def set_general(ark_id): if "external_url" in data: external_url = data.get("external_url") - return add_url(ark_id, external_url) + + if async_mode == "ASYNC": + return asyncio.run(add_url(ark_id, external_url)) + else: + return add_url(ark_id, external_url) if "external_pid" in data: pid = data.get("external_pid") @@ -290,4 +177,11 @@ def set_general(ark_id): payload = data return set_payload(ark_id, payload) - return jsonify({"error": "Invalid or missing data in the request. Please check your input and try again."}), 400 + return ( + jsonify( + { + "error": "Invalid or missing data in the request. Please check your input and try again." + } + ), + 400, + ) diff --git a/app/api/synchronous/functions.py b/app/api/synchronous/functions.py new file mode 100644 index 0000000..fbebe98 --- /dev/null +++ b/app/api/synchronous/functions.py @@ -0,0 +1,166 @@ +import json +import os +import configparser + +from flask import Blueprint, Flask, jsonify, render_template, send_file, abort, request +from web3 import Web3 + +from dark import DarkMap, DarkGateway +from util.validation import ValidationUtil +from util.config_manager import ConfigManager + +# configurando classe das váriaveis externas +config_manager = ConfigManager() + +core_api_blueprint = Blueprint("core_api", __name__, url_prefix="/core") + +## +# configuring dARK GW +## + +bc_config = configparser.ConfigParser() +deployed_contracts_config = configparser.ConfigParser() + +# bc configuration +PROJECT_ROOT = "./" +bc_config.read(os.path.join(PROJECT_ROOT, "config.ini")) +# deployed contracts config +deployed_contracts_config.read(os.path.join(PROJECT_ROOT, "deployed_contracts.ini")) + + +# gw +dark_gw = DarkGateway(bc_config, deployed_contracts_config) + +# +dark_map = DarkMap(dark_gw) + +### +### methods +### + + +# Set the external variable -> config_manager.set_url_validation("BASIC") +def add_url(ark_id, external_url): + try: + VERIFICATION_METHOD = config_manager.get_url_validation() + except: + VERIFICATION_METHOD = None + + try: + pid = None + if ark_id.startswith("0x"): + pid = dark_map.get_pid_by_hash(ark_id) + else: + pid = dark_map.get_pid_by_ark(ark_id) + + if VERIFICATION_METHOD == "BASIC": + if ValidationUtil.check_url(external_url) == False: + return jsonify({"error": "Invalid URL"}), 400 + elif VERIFICATION_METHOD == "NONE" or VERIFICATION_METHOD == None: + if len(external_url) == 0: + return jsonify({"error": "Invalid URL"}), 400 + else: + return jsonify({"error": "the method could not be implemented"}), 400 + + dark_map.sync_set_url(pid.pid_hash, external_url) + + return ( + jsonify( + { + "pid": str(pid.ark), + "action": "external_url_add", + "parameter": external_url, + } + ), + 200, + ) + + except Exception as e: + return jsonify({"error": str(e)}), 400 + + +# Set the external variable -> config_manager.set_external_pid_validation("BASIC") +def add_external_pid(ark_id, external_pid): + try: + VERIFICATION_METHOD = config_manager.get_external_pid_validation() + + except: + VERIFICATION_METHOD = None + + try: + pid = None + + if ark_id.startswith("0x"): + pid = dark_map.get_pid_by_hash(ark_id) + else: + pid = dark_map.get_pid_by_ark(ark_id) + + if VERIFICATION_METHOD == "BASIC": + if external_pid.startswith("doi:/") == False: + return jsonify({"error": "Invalid Pid"}), 400 + + elif VERIFICATION_METHOD == "NONE" or VERIFICATION_METHOD == None: + if len(external_pid) == 0: + return jsonify({"error": "Invalid Pid"}), 400 + else: + return jsonify({"error": "the method could not be implemented"}), 400 + + valid_pid = external_pid.split(":/")[1] + dark_map.sync_add_external_pid(pid.pid_hash, valid_pid) + + return ( + jsonify( + { + "pid": str(pid.ark), + "action": "external_pid_add", + "parameter": valid_pid, + } + ), + 200, + ) + + except Exception as e: + return jsonify({"error": str(e)}), 400 + + +# Set the external variable -> config_manager.set_payload_validation("BASIC") +def set_payload(ark_id, payload): + try: + VERIFICATION_METHOD = config_manager.get_payload_validation() + + except: + VERIFICATION_METHOD = None + + try: + if VERIFICATION_METHOD == "BASIC": + payload = json.loads(payload) + + if type(payload) != dict or len(payload) == 0: + return jsonify({"error": "Invalid JSON payload"}), 400 + + elif VERIFICATION_METHOD == "NONE" or VERIFICATION_METHOD == None: + if type(payload) != dict or len(payload) == 0: + return jsonify({"error": "Invalid JSON payload"}), 400 + else: + return jsonify({"error": "the method could not be implemented"}), 400 + + if ark_id.startswith("0x"): + pid = dark_map.get_pid_by_hash(ark_id) + else: + pid = dark_map.get_pid_by_ark(ark_id) + + dark_map.sync_set_payload(pid.pid_hash, payload) + + return ( + jsonify( + { + "pid": str(pid.ark), + "action": "payload_add", + "parameter": payload, + } + ), + 200, + ) + + except Exception as e: + return jsonify({"error": str(e)}), 400 diff --git a/app/util/config_manager.py b/app/util/config_manager.py index 50aca43..a2a0b23 100644 --- a/app/util/config_manager.py +++ b/app/util/config_manager.py @@ -1,15 +1,14 @@ import os - class ConfigManager: EXTERNAL_PID_PARAMETER = "external_pid" EXTERNAL_URL_PARAMETER = "external_url" def __init__(self): - # Configuração padrão para variáveis de ambiente, se não definidas os.environ.setdefault("HYPERDRIVE_EXTERNAL_PID_VALIDATION", "NONE") os.environ.setdefault("HYPERDRIVE_URL_VALIDATION", "NONE") os.environ.setdefault("HYPERDRIVE_PAYLOAD_VALIDATION", "NONE") + os.environ.setdefault("HYPERDRIVE_OPERATION_MODE", "ASYNC") def get_external_pid_validation(self): return os.environ["HYPERDRIVE_EXTERNAL_PID_VALIDATION"] @@ -28,3 +27,9 @@ def get_payload_validation(self): def set_payload_validation(self, value): os.environ["HYPERDRIVE_PAYLOAD_VALIDATION"] = value + + def get_operation_mode(self): + return os.environ["HYPERDRIVE_OPERATION_MODE"] + + def set_operation_mode(self, value): + os.environ["HYPERDRIVE_OPERATION_MODE"] = value From 0d606918c6ef9023c359f959acf60366062b8599 Mon Sep 17 00:00:00 2001 From: samuelfsd Date: Thu, 28 Sep 2023 20:27:39 -0300 Subject: [PATCH 02/11] fix: sync errors correcting --- app/api/core_api.py | 15 ++++-- .../functions.py => util/asynchronus.py} | 53 +++++++++++++++++-- app/util/config_manager.py | 1 + .../functions.py => util/synchronous.py} | 0 4 files changed, 61 insertions(+), 8 deletions(-) rename app/{api/asynchronus/functions.py => util/asynchronus.py} (55%) rename app/{api/synchronous/functions.py => util/synchronous.py} (100%) diff --git a/app/api/core_api.py b/app/api/core_api.py index 5f9c812..117da09 100644 --- a/app/api/core_api.py +++ b/app/api/core_api.py @@ -19,8 +19,10 @@ async_mode = config_manager.get_operation_mode() -from .synchronous.functions import add_url, add_external_pid, set_payload -from .asynchronus.functions import add_url +if async_mode == "ASYNC": + from util.asynchronus import add_url, set_payload +else: + from util.synchronous import add_url, add_external_pid, set_payload ## @@ -146,7 +148,6 @@ def get_pid_by_noid(nam, shoulder): @core_api_blueprint.post("/set/") def set_general(ark_id): if request.is_json: - print(async_mode) data = request.get_json() if len(data) == 0: return jsonify({"error": "No parameter has been passed"}), 405 @@ -166,7 +167,7 @@ def set_general(ark_id): if async_mode == "ASYNC": return asyncio.run(add_url(ark_id, external_url)) - else: + if async_mode == "SYNC": return add_url(ark_id, external_url) if "external_pid" in data: @@ -175,7 +176,11 @@ def set_general(ark_id): if "payload" in data: payload = data - return set_payload(ark_id, payload) + + if async_mode == "ASYNC": + return asyncio.run(set_payload(ark_id, payload)) + if async_mode == "SYNC": + return set_payload(ark_id, payload) return ( jsonify( diff --git a/app/api/asynchronus/functions.py b/app/util/asynchronus.py similarity index 55% rename from app/api/asynchronus/functions.py rename to app/util/asynchronus.py index 0f773f3..9c3f367 100644 --- a/app/api/asynchronus/functions.py +++ b/app/util/asynchronus.py @@ -72,17 +72,64 @@ async def add_url(ark_id, external_url): ) tx_set = dark_map.async_set_url(pid.pid_hash, external_url) - tx_status = dark_gw.transaction_was_executed(tx_set) + tx_status, tx_recipt = dark_gw.transaction_was_executed(tx_set) result = { "pid": str(pid.ark), - "pid_hash_index": str(pid.__hash__), + "pid_hash_index": Web3.toHex(pid.pid_hash), "action": "add_url", "parameter": external_url, - "transaction_hash": tx_status, + "transaction_hash": tx_recipt, + "tx_status": tx_status, + "status": "queued", } return result, 200 except Exception as e: return make_response(jsonify({"error": str(e)}), 400) + + +# Set the external variable -> config_manager.set_payload_validation("BASIC") +async def set_payload(ark_id, payload): + try: + VERIFICATION_METHOD = config_manager.get_payload_validation() + + except: + VERIFICATION_METHOD = None + + try: + if VERIFICATION_METHOD == "BASIC": + payload = json.loads(payload) + + if type(payload) != dict or len(payload) == 0: + return jsonify({"error": "Invalid JSON payload"}), 400 + + elif VERIFICATION_METHOD == "NONE" or VERIFICATION_METHOD == None: + if type(payload) != dict or len(payload) == 0: + return jsonify({"error": "Invalid JSON payload"}), 400 + else: + return jsonify({"error": "the method could not be implemented"}), 400 + + if ark_id.startswith("0x"): + pid = dark_map.get_pid_by_hash(ark_id) + else: + pid = dark_map.get_pid_by_ark(ark_id) + + tx_set = dark_map.async_set_payload(pid.pid_hash, payload) + tx_status, tx_recipt = dark_gw.transaction_was_executed(tx_set) + + result = { + "pid": str(pid.ark), + "pid_hash_index": Web3.toHex(pid.pid_hash), + "action": "set_payload", + "parameter": payload, + "transaction_hash": tx_recipt, + "tx_status": tx_status, + "status": "queued", + } + + return result, 200 + + except Exception as e: + return jsonify({"error": str(e)}), 400 diff --git a/app/util/config_manager.py b/app/util/config_manager.py index a2a0b23..1972b37 100644 --- a/app/util/config_manager.py +++ b/app/util/config_manager.py @@ -1,5 +1,6 @@ import os + class ConfigManager: EXTERNAL_PID_PARAMETER = "external_pid" EXTERNAL_URL_PARAMETER = "external_url" diff --git a/app/api/synchronous/functions.py b/app/util/synchronous.py similarity index 100% rename from app/api/synchronous/functions.py rename to app/util/synchronous.py From 721fe90eef0024d09ab19c741c3daa8561d2fdce Mon Sep 17 00:00:00 2001 From: Francileudo Oliveira Date: Fri, 29 Sep 2023 16:35:32 -0300 Subject: [PATCH 03/11] feat: async method for pid added --- app/api/core_api.py | 8 ++++++-- app/util/asynchronus.py | 45 +++++++++++++++++++++++++++++++++++++++++ 2 files changed, 51 insertions(+), 2 deletions(-) diff --git a/app/api/core_api.py b/app/api/core_api.py index 117da09..6744ef3 100644 --- a/app/api/core_api.py +++ b/app/api/core_api.py @@ -20,7 +20,7 @@ async_mode = config_manager.get_operation_mode() if async_mode == "ASYNC": - from util.asynchronus import add_url, set_payload + from util.asynchronus import add_url, add_external_pid, set_payload else: from util.synchronous import add_url, add_external_pid, set_payload @@ -172,7 +172,11 @@ def set_general(ark_id): if "external_pid" in data: pid = data.get("external_pid") - return add_external_pid(ark_id, pid) + + if async_mode == "ASYNC": + return asyncio.run(add_external_pid(ark_id, pid)) + if async_mode == "SYNC": + return add_external_pid(ark_id, pid) if "payload" in data: payload = data diff --git a/app/util/asynchronus.py b/app/util/asynchronus.py index 9c3f367..a12ac12 100644 --- a/app/util/asynchronus.py +++ b/app/util/asynchronus.py @@ -89,6 +89,51 @@ async def add_url(ark_id, external_url): except Exception as e: return make_response(jsonify({"error": str(e)}), 400) +# Set the external variable -> config_manager.set_external_pid_validation("BASIC") +async def add_external_pid(ark_id, external_pid): + try: + VERIFICATION_METHOD = config_manager.get_external_pid_validation() + + except: + VERIFICATION_METHOD = None + + try: + pid = None + + if ark_id.startswith("0x"): + pid = dark_map.get_pid_by_hash(ark_id) + else: + pid = dark_map.get_pid_by_ark(ark_id) + + if VERIFICATION_METHOD == "BASIC": + if external_pid.startswith("doi:/") == False: + return make_response(jsonify({"error": "Invalid Pid"}), 400) + + elif VERIFICATION_METHOD == "NONE" or VERIFICATION_METHOD == None: + if len(external_pid) == 0: + return make_response(jsonify({"error": "Invalid Pid"}), 400) + else: + return make_response(jsonify({"error": "the method could not be implemented"}), 400) + + valid_pid = external_pid.split(":/")[1] + tx_set = dark_map.async_set_external_pid(pid.pid_hash, valid_pid) + tx_status, tx_recipt = dark_gw.transaction_was_executed(tx_set) + + result = { + "pid": str(pid.ark), + "pid_hash_index": str(pid.__hash__), + "action": "external_pid_add", + "parameter": valid_pid, + "transaction_hash": tx_recipt, + "tx_status": tx_status, + "status": "queued", + } + + return result, 200 + + except Exception as e: + return make_response(jsonify({"error": str(e)}), 400) + # Set the external variable -> config_manager.set_payload_validation("BASIC") async def set_payload(ark_id, payload): From 6eddeb2ae7386172d5f1799376a0062ec25d68ea Mon Sep 17 00:00:00 2001 From: Francileudo Oliveira Date: Fri, 29 Sep 2023 16:38:28 -0300 Subject: [PATCH 04/11] refactor: standardizing responses from url, pid and payload addition functions --- app/util/synchronous.py | 53 +++++++++++++++++++---------------------- 1 file changed, 25 insertions(+), 28 deletions(-) diff --git a/app/util/synchronous.py b/app/util/synchronous.py index fbebe98..5679d52 100644 --- a/app/util/synchronous.py +++ b/app/util/synchronous.py @@ -64,16 +64,15 @@ def add_url(ark_id, external_url): dark_map.sync_set_url(pid.pid_hash, external_url) - return ( - jsonify( - { - "pid": str(pid.ark), - "action": "external_url_add", - "parameter": external_url, - } - ), - 200, - ) + result = { + "pid": str(pid.ark), + "pid_hash_index": Web3.toHex(pid.pid_hash), + "action": "add_url", + "parameter": external_url, + "status": "queued", + } + + return jsonify(result), 200 except Exception as e: return jsonify({"error": str(e)}), 400 @@ -108,16 +107,15 @@ def add_external_pid(ark_id, external_pid): valid_pid = external_pid.split(":/")[1] dark_map.sync_add_external_pid(pid.pid_hash, valid_pid) - return ( - jsonify( - { + result = { "pid": str(pid.ark), - "action": "external_pid_add", + "pid_hash_index": str(pid.__hash__), + "action": "external_pid_add", "parameter": valid_pid, - } - ), - 200, - ) + "status": "queued", + } + + return jsonify(result), 200 except Exception as e: return jsonify({"error": str(e)}), 400 @@ -151,16 +149,15 @@ def set_payload(ark_id, payload): dark_map.sync_set_payload(pid.pid_hash, payload) - return ( - jsonify( - { - "pid": str(pid.ark), - "action": "payload_add", - "parameter": payload, - } - ), - 200, - ) + result = { + "pid": str(pid.ark), + "pid_hash_index": Web3.toHex(pid.pid_hash), + "action": "set_payload", + "parameter": payload, + "status": "queued", + } + + return jsonify(result), 200 except Exception as e: return jsonify({"error": str(e)}), 400 From ecafae46950a55ca45fca4b782733a4642cf892d Mon Sep 17 00:00:00 2001 From: samuelfsd Date: Tue, 3 Oct 2023 19:52:14 -0300 Subject: [PATCH 05/11] feat: standardize hyperdrive response messages --- app/util/asynchronus.py | 68 +++++++++++++++-------------------------- app/util/responses.py | 40 ++++++++++++++++++++++++ app/util/synchronous.py | 56 ++++++++++++++------------------- 3 files changed, 88 insertions(+), 76 deletions(-) create mode 100644 app/util/responses.py diff --git a/app/util/asynchronus.py b/app/util/asynchronus.py index a12ac12..76c4231 100644 --- a/app/util/asynchronus.py +++ b/app/util/asynchronus.py @@ -16,10 +16,13 @@ from dark import DarkMap, DarkGateway from util.validation import ValidationUtil +from util.responses import success_response, error_response from util.config_manager import ConfigManager + # configurando classe das váriaveis externas config_manager = ConfigManager() +async_mode = config_manager.get_operation_mode() ## # configuring dARK GW @@ -54,6 +57,7 @@ async def add_url(ark_id, external_url): VERIFICATION_METHOD = None try: + action = "add_url" pid = None if ark_id.startswith("0x"): pid = dark_map.get_pid_by_hash(ark_id) @@ -62,33 +66,24 @@ async def add_url(ark_id, external_url): if VERIFICATION_METHOD == "BASIC": if ValidationUtil.check_url(external_url) == False: - return make_response(jsonify({"error": "Invalid URL"}), 400) + return make_response(error_response(pid,async_mode.lower(), action, external_url, "Invalid URL", 400)) elif VERIFICATION_METHOD == "NONE" or VERIFICATION_METHOD == None: if len(external_url) == 0: - return make_response(jsonify({"error": "Invalid URL"}), 400) + return make_response(error_response(pid,async_mode.lower(), action, external_url, "Invalid URL", 400)) else: - return make_response( - jsonify({"error": "the method could not be implemented"}), 400 - ) + return make_response(error_response(pid,async_mode.lower(), action, external_url, "the method could not be implemented", 400)) tx_set = dark_map.async_set_url(pid.pid_hash, external_url) tx_status, tx_recipt = dark_gw.transaction_was_executed(tx_set) - result = { - "pid": str(pid.ark), - "pid_hash_index": Web3.toHex(pid.pid_hash), - "action": "add_url", - "parameter": external_url, - "transaction_hash": tx_recipt, - "tx_status": tx_status, - "status": "queued", - } + response = success_response(pid, async_mode.lower(), action, external_url, "queued") - return result, 200 + return response except Exception as e: return make_response(jsonify({"error": str(e)}), 400) + # Set the external variable -> config_manager.set_external_pid_validation("BASIC") async def add_external_pid(ark_id, external_pid): try: @@ -98,8 +93,9 @@ async def add_external_pid(ark_id, external_pid): VERIFICATION_METHOD = None try: + action = "add_external_pid" pid = None - + if ark_id.startswith("0x"): pid = dark_map.get_pid_by_hash(ark_id) else: @@ -107,29 +103,21 @@ async def add_external_pid(ark_id, external_pid): if VERIFICATION_METHOD == "BASIC": if external_pid.startswith("doi:/") == False: - return make_response(jsonify({"error": "Invalid Pid"}), 400) + return make_response(error_response(pid,async_mode.lower(), action, external_pid, "Invalid PID", 400)) elif VERIFICATION_METHOD == "NONE" or VERIFICATION_METHOD == None: if len(external_pid) == 0: - return make_response(jsonify({"error": "Invalid Pid"}), 400) + return make_response(error_response(pid,async_mode.lower(), action, external_pid, "Invalid PID", 400)) else: - return make_response(jsonify({"error": "the method could not be implemented"}), 400) + return make_response(error_response(pid,async_mode.lower(), action, external_pid,"queued" ,"the method could not, be implemented", 400)) valid_pid = external_pid.split(":/")[1] tx_set = dark_map.async_set_external_pid(pid.pid_hash, valid_pid) tx_status, tx_recipt = dark_gw.transaction_was_executed(tx_set) - result = { - "pid": str(pid.ark), - "pid_hash_index": str(pid.__hash__), - "action": "external_pid_add", - "parameter": valid_pid, - "transaction_hash": tx_recipt, - "tx_status": tx_status, - "status": "queued", - } + response = success_response(pid, async_mode.lower(), action, external_pid, "queued") - return result, 200 + return response except Exception as e: return make_response(jsonify({"error": str(e)}), 400) @@ -144,17 +132,19 @@ async def set_payload(ark_id, payload): VERIFICATION_METHOD = None try: + action = "set_payload" + pid = None if VERIFICATION_METHOD == "BASIC": payload = json.loads(payload) if type(payload) != dict or len(payload) == 0: - return jsonify({"error": "Invalid JSON payload"}), 400 + return make_response(error_response(pid,async_mode.lower(), action, payload, "Invalid JSON payload", 400)) elif VERIFICATION_METHOD == "NONE" or VERIFICATION_METHOD == None: if type(payload) != dict or len(payload) == 0: - return jsonify({"error": "Invalid JSON payload"}), 400 + return make_response(error_response(pid,async_mode.lower(), action, payload, "Invalid JSON payload", 400)) else: - return jsonify({"error": "the method could not be implemented"}), 400 + return make_response(error_response(pid,async_mode.lower(), action, payload, "the method could not be implemented", 400)) if ark_id.startswith("0x"): pid = dark_map.get_pid_by_hash(ark_id) @@ -164,17 +154,9 @@ async def set_payload(ark_id, payload): tx_set = dark_map.async_set_payload(pid.pid_hash, payload) tx_status, tx_recipt = dark_gw.transaction_was_executed(tx_set) - result = { - "pid": str(pid.ark), - "pid_hash_index": Web3.toHex(pid.pid_hash), - "action": "set_payload", - "parameter": payload, - "transaction_hash": tx_recipt, - "tx_status": tx_status, - "status": "queued", - } - - return result, 200 + response = success_response(pid, async_mode.lower(), action, payload,"queued") + + return response except Exception as e: return jsonify({"error": str(e)}), 400 diff --git a/app/util/responses.py b/app/util/responses.py new file mode 100644 index 0000000..25487b5 --- /dev/null +++ b/app/util/responses.py @@ -0,0 +1,40 @@ +from flask import jsonify +from web3 import Web3 + + +def success_response(pid, op_mode, action, parameter,status, tx_receipt=None, tx_status=None): + if op_mode == "sync": + status = "executed" + else: + status = "queued" + + response_data = { + "pid": str(pid.ark), + "pid_hash_index": Web3.toHex(pid.pid_hash), + "action": action, + "parameter": {"pid": str(pid.ark), action: parameter}, + "status": status, + "hyperdrive_op_mode": op_mode.lower(), + } + + if tx_receipt != None or tx_status is not None: + response_data["transaction_hash"] = tx_receipt + response_data["tx_status"] = tx_status + + return jsonify(response_data), 200 + + +def error_response(pid, op_mode, action, parameter, error_message, error_code): + error_response = { + "error": { + "pid": str(pid.ark), + "pid_hash_index": Web3.toHex(pid.pid_hash), + "message": error_message, + "error_code": error_code, + "action": action, + "parameter": {"pid": str(pid.ark), "external_url": parameter}, + "status": "rejected", + "hyperdrive_op_mode": op_mode.lower(), + } + } + return jsonify(error_response), 400 diff --git a/app/util/synchronous.py b/app/util/synchronous.py index 5679d52..84d4f99 100644 --- a/app/util/synchronous.py +++ b/app/util/synchronous.py @@ -7,10 +7,12 @@ from dark import DarkMap, DarkGateway from util.validation import ValidationUtil +from util.responses import success_response, error_response from util.config_manager import ConfigManager # configurando classe das váriaveis externas config_manager = ConfigManager() +async_mode = config_manager.get_operation_mode() core_api_blueprint = Blueprint("core_api", __name__, url_prefix="/core") @@ -47,7 +49,9 @@ def add_url(ark_id, external_url): VERIFICATION_METHOD = None try: + action = "add_url" pid = None + if ark_id.startswith("0x"): pid = dark_map.get_pid_by_hash(ark_id) else: @@ -55,24 +59,18 @@ def add_url(ark_id, external_url): if VERIFICATION_METHOD == "BASIC": if ValidationUtil.check_url(external_url) == False: - return jsonify({"error": "Invalid URL"}), 400 + return error_response(pid,async_mode.lower(), action, external_url,"Invalid URL", 400) elif VERIFICATION_METHOD == "NONE" or VERIFICATION_METHOD == None: if len(external_url) == 0: - return jsonify({"error": "Invalid URL"}), 400 + return error_response(pid,async_mode.lower(), action, external_url,"Invalid URL", 400) else: - return jsonify({"error": "the method could not be implemented"}), 400 + return error_response(pid,async_mode.lower(), action, external_url, "the method could not be implemented", 400) dark_map.sync_set_url(pid.pid_hash, external_url) - result = { - "pid": str(pid.ark), - "pid_hash_index": Web3.toHex(pid.pid_hash), - "action": "add_url", - "parameter": external_url, - "status": "queued", - } + response = success_response(pid, async_mode.lower(), action, external_url, "executed") - return jsonify(result), 200 + return response except Exception as e: return jsonify({"error": str(e)}), 400 @@ -87,6 +85,7 @@ def add_external_pid(ark_id, external_pid): VERIFICATION_METHOD = None try: + action = "add_external_pid" pid = None if ark_id.startswith("0x"): @@ -96,26 +95,20 @@ def add_external_pid(ark_id, external_pid): if VERIFICATION_METHOD == "BASIC": if external_pid.startswith("doi:/") == False: - return jsonify({"error": "Invalid Pid"}), 400 + return error_response(pid,async_mode.lower(), action, external_pid, "Invalid PID", 400) elif VERIFICATION_METHOD == "NONE" or VERIFICATION_METHOD == None: if len(external_pid) == 0: - return jsonify({"error": "Invalid Pid"}), 400 + return error_response(pid,async_mode.lower(), action, external_pid, "Invalid PID", 400) else: - return jsonify({"error": "the method could not be implemented"}), 400 + return error_response(pid,async_mode.lower(), action, external_pid,"queued" ,"the method could not, be implemented", 400) valid_pid = external_pid.split(":/")[1] dark_map.sync_add_external_pid(pid.pid_hash, valid_pid) - result = { - "pid": str(pid.ark), - "pid_hash_index": str(pid.__hash__), - "action": "external_pid_add", - "parameter": valid_pid, - "status": "queued", - } + response = success_response(pid, async_mode.lower(), action, external_pid, "executed") - return jsonify(result), 200 + return response except Exception as e: return jsonify({"error": str(e)}), 400 @@ -130,17 +123,20 @@ def set_payload(ark_id, payload): VERIFICATION_METHOD = None try: + action = "set_payload" + pid = None + if VERIFICATION_METHOD == "BASIC": payload = json.loads(payload) if type(payload) != dict or len(payload) == 0: - return jsonify({"error": "Invalid JSON payload"}), 400 + return error_response(pid,async_mode.lower(), action, payload, "Invalid JSON payload", 400) elif VERIFICATION_METHOD == "NONE" or VERIFICATION_METHOD == None: if type(payload) != dict or len(payload) == 0: - return jsonify({"error": "Invalid JSON payload"}), 400 + return error_response(pid,async_mode.lower(), action, payload, "Invalid JSON payload", 400) else: - return jsonify({"error": "the method could not be implemented"}), 400 + return error_response(pid,async_mode.lower(), action, payload, "the method could not be implemented", 400) if ark_id.startswith("0x"): pid = dark_map.get_pid_by_hash(ark_id) @@ -149,15 +145,9 @@ def set_payload(ark_id, payload): dark_map.sync_set_payload(pid.pid_hash, payload) - result = { - "pid": str(pid.ark), - "pid_hash_index": Web3.toHex(pid.pid_hash), - "action": "set_payload", - "parameter": payload, - "status": "queued", - } + response = success_response(pid, async_mode.lower(), action, payload,"executed") - return jsonify(result), 200 + return response except Exception as e: return jsonify({"error": str(e)}), 400 From 545f886aa814598b9b77c31d60538cdd0c54c211 Mon Sep 17 00:00:00 2001 From: samuelfsd Date: Wed, 11 Oct 2023 17:32:13 -0300 Subject: [PATCH 06/11] feat: convert tx_set to hash --- app/util/asynchronus.py | 10 ++++------ app/util/responses.py | 4 +++- 2 files changed, 7 insertions(+), 7 deletions(-) diff --git a/app/util/asynchronus.py b/app/util/asynchronus.py index 76c4231..4e97fde 100644 --- a/app/util/asynchronus.py +++ b/app/util/asynchronus.py @@ -74,9 +74,8 @@ async def add_url(ark_id, external_url): return make_response(error_response(pid,async_mode.lower(), action, external_url, "the method could not be implemented", 400)) tx_set = dark_map.async_set_url(pid.pid_hash, external_url) - tx_status, tx_recipt = dark_gw.transaction_was_executed(tx_set) - response = success_response(pid, async_mode.lower(), action, external_url, "queued") + response = success_response(pid, async_mode.lower(), action, external_url, "queued", tx_receipt=tx_set.hex()) return response @@ -95,7 +94,7 @@ async def add_external_pid(ark_id, external_pid): try: action = "add_external_pid" pid = None - + if ark_id.startswith("0x"): pid = dark_map.get_pid_by_hash(ark_id) else: @@ -113,9 +112,8 @@ async def add_external_pid(ark_id, external_pid): valid_pid = external_pid.split(":/")[1] tx_set = dark_map.async_set_external_pid(pid.pid_hash, valid_pid) - tx_status, tx_recipt = dark_gw.transaction_was_executed(tx_set) - response = success_response(pid, async_mode.lower(), action, external_pid, "queued") + response = success_response(pid, async_mode.lower(), action, external_pid, "queued", tx_receipt=tx_set.hex()) return response @@ -154,7 +152,7 @@ async def set_payload(ark_id, payload): tx_set = dark_map.async_set_payload(pid.pid_hash, payload) tx_status, tx_recipt = dark_gw.transaction_was_executed(tx_set) - response = success_response(pid, async_mode.lower(), action, payload,"queued") + response = success_response(pid, async_mode.lower(), action, payload,"queued", tx_receipt=tx_set.hex()) return response diff --git a/app/util/responses.py b/app/util/responses.py index 25487b5..dabb22e 100644 --- a/app/util/responses.py +++ b/app/util/responses.py @@ -17,8 +17,10 @@ def success_response(pid, op_mode, action, parameter,status, tx_receipt=None, tx "hyperdrive_op_mode": op_mode.lower(), } - if tx_receipt != None or tx_status is not None: + if tx_receipt != None: response_data["transaction_hash"] = tx_receipt + + if tx_status != None: response_data["tx_status"] = tx_status return jsonify(response_data), 200 From 5ad89b1427bb4c529fcb40c470d106448f175896 Mon Sep 17 00:00:00 2001 From: Francileudo Oliveira Date: Thu, 12 Oct 2023 20:32:52 -0300 Subject: [PATCH 07/11] test: initial validation testing of the url addition method --- tests/unit/test_methods_validation.py | 41 +++++++++++++++++++++++++++ 1 file changed, 41 insertions(+) create mode 100644 tests/unit/test_methods_validation.py diff --git a/tests/unit/test_methods_validation.py b/tests/unit/test_methods_validation.py new file mode 100644 index 0000000..39e9bb2 --- /dev/null +++ b/tests/unit/test_methods_validation.py @@ -0,0 +1,41 @@ +import pytest +from flask import jsonify +from app.util.validation import ValidationUtil +from app.util.config_manager import ConfigManager + + +config_manager = ConfigManager() + + +# tests for synchronous external url addition method + +def mock_add_url(VERIFICATION_METHOD, external_url): + try: + # Simulates URL validation behavior + if VERIFICATION_METHOD == "BASIC": + if ValidationUtil.check_url(external_url) == False: + return {"status": "error", "message": "invalid url"}, 400 + elif VERIFICATION_METHOD == "NONE" or VERIFICATION_METHOD == None: + if len(external_url) == 0: + return {"status": "error", "message": "invalid url"}, 400 + else: + return {"status": "error", "message": "the method could not be implemented"}, 400 + + # Simulates a successful response + return {"status": "success", "message": "executed"}, 200 + + except Exception as e: + # Simulates a generic error response + return jsonify({"error": str(e)}), 400 + +def test_add_url_validation_success(): + config_manager.set_url_validation("BASIC") + VERIFICATION_METHOD = config_manager.get_url_validation() + result = mock_add_url(VERIFICATION_METHOD, "http://www.uol.com/123456") + assert 200 in result + +def test_add_url_validation_failure(): + config_manager.set_url_validation("BASIC") + VERIFICATION_METHOD = config_manager.get_url_validation() + result = mock_add_url(VERIFICATION_METHOD, "invalid_url") + assert 400 in result From 52d533f8029d68f7f9042be5ca0b28a138fc365a Mon Sep 17 00:00:00 2001 From: Francileudo Oliveira Date: Fri, 13 Oct 2023 14:16:10 -0300 Subject: [PATCH 08/11] test: removing tests from the branch --- tests/unit/test_methods_validation.py | 41 --------------------------- 1 file changed, 41 deletions(-) delete mode 100644 tests/unit/test_methods_validation.py diff --git a/tests/unit/test_methods_validation.py b/tests/unit/test_methods_validation.py deleted file mode 100644 index 39e9bb2..0000000 --- a/tests/unit/test_methods_validation.py +++ /dev/null @@ -1,41 +0,0 @@ -import pytest -from flask import jsonify -from app.util.validation import ValidationUtil -from app.util.config_manager import ConfigManager - - -config_manager = ConfigManager() - - -# tests for synchronous external url addition method - -def mock_add_url(VERIFICATION_METHOD, external_url): - try: - # Simulates URL validation behavior - if VERIFICATION_METHOD == "BASIC": - if ValidationUtil.check_url(external_url) == False: - return {"status": "error", "message": "invalid url"}, 400 - elif VERIFICATION_METHOD == "NONE" or VERIFICATION_METHOD == None: - if len(external_url) == 0: - return {"status": "error", "message": "invalid url"}, 400 - else: - return {"status": "error", "message": "the method could not be implemented"}, 400 - - # Simulates a successful response - return {"status": "success", "message": "executed"}, 200 - - except Exception as e: - # Simulates a generic error response - return jsonify({"error": str(e)}), 400 - -def test_add_url_validation_success(): - config_manager.set_url_validation("BASIC") - VERIFICATION_METHOD = config_manager.get_url_validation() - result = mock_add_url(VERIFICATION_METHOD, "http://www.uol.com/123456") - assert 200 in result - -def test_add_url_validation_failure(): - config_manager.set_url_validation("BASIC") - VERIFICATION_METHOD = config_manager.get_url_validation() - result = mock_add_url(VERIFICATION_METHOD, "invalid_url") - assert 400 in result From 3cf88ebffa1261461e4cd2a39faafcf38d0b1452 Mon Sep 17 00:00:00 2001 From: Francileudo Oliveira Date: Fri, 13 Oct 2023 14:29:59 -0300 Subject: [PATCH 09/11] test: initial validation testing of the url addition method --- tests/unit/tests_validation_methods.py | 41 ++++++++++++++++++++++++++ 1 file changed, 41 insertions(+) create mode 100644 tests/unit/tests_validation_methods.py diff --git a/tests/unit/tests_validation_methods.py b/tests/unit/tests_validation_methods.py new file mode 100644 index 0000000..65f8e80 --- /dev/null +++ b/tests/unit/tests_validation_methods.py @@ -0,0 +1,41 @@ +import pytest +from flask import jsonify +from app.util.validation import ValidationUtil +from app.util.config_manager import ConfigManager + + +config_manager = ConfigManager() + + +# tests for synchronous external url addition method + +def mock_add_url(VERIFICATION_METHOD, external_url): + try: + # Simulates URL validation behavior + if VERIFICATION_METHOD == "BASIC": + if ValidationUtil.check_url(external_url) == False: + return {"status": "error", "message": "invalid url"}, 400 + elif VERIFICATION_METHOD == "NONE" or VERIFICATION_METHOD == None: + if len(external_url) == 0: + return {"status": "error", "message": "invalid url"}, 400 + else: + return {"status": "error", "message": "the method could not be implemented"}, 400 + + # Simulates a successful response + return {"status": "success", "message": "executed"}, 200 + + except Exception as e: + # Simulates a generic error response + return jsonify({"error": str(e)}), 400 + +def test_add_url_valid(): + config_manager.set_url_validation("BASIC") + VERIFICATION_METHOD = config_manager.get_url_validation() + result = mock_add_url(VERIFICATION_METHOD, "http://www.uol.com/123456") + assert 200 in result + +def test_add_url_invalid(): + config_manager.set_url_validation("BASIC") + VERIFICATION_METHOD = config_manager.get_url_validation() + result = mock_add_url(VERIFICATION_METHOD, "hello 123") + assert 400 in result From 0d788d101770527b8d3bea4eadb8f00973c9f05a Mon Sep 17 00:00:00 2001 From: Francileudo Oliveira Date: Fri, 13 Oct 2023 17:21:09 -0300 Subject: [PATCH 10/11] fix: fixing payload validation error in set_payload --- app/api/core_api.py | 2 +- app/util/asynchronus.py | 22 ++++++++++++---------- app/util/synchronous.py | 19 ++++++++++--------- 3 files changed, 23 insertions(+), 20 deletions(-) diff --git a/app/api/core_api.py b/app/api/core_api.py index 6744ef3..3def6d6 100644 --- a/app/api/core_api.py +++ b/app/api/core_api.py @@ -179,7 +179,7 @@ def set_general(ark_id): return add_external_pid(ark_id, pid) if "payload" in data: - payload = data + payload = data.get("payload") if async_mode == "ASYNC": return asyncio.run(set_payload(ark_id, payload)) diff --git a/app/util/asynchronus.py b/app/util/asynchronus.py index 4e97fde..b33f05e 100644 --- a/app/util/asynchronus.py +++ b/app/util/asynchronus.py @@ -132,23 +132,25 @@ async def set_payload(ark_id, payload): try: action = "set_payload" pid = None - if VERIFICATION_METHOD == "BASIC": - payload = json.loads(payload) - if type(payload) != dict or len(payload) == 0: - return make_response(error_response(pid,async_mode.lower(), action, payload, "Invalid JSON payload", 400)) + if ark_id.startswith("0x"): + pid = dark_map.get_pid_by_hash(ark_id) + else: + pid = dark_map.get_pid_by_ark(ark_id) + + if VERIFICATION_METHOD == "BASIC": + if type(payload) != dict: + try: + payload = json.loads(payload) + except Exception as e: + return error_response(pid,async_mode.lower(), action, payload, "Invalid JSON payload", 400) elif VERIFICATION_METHOD == "NONE" or VERIFICATION_METHOD == None: - if type(payload) != dict or len(payload) == 0: + if len(payload) == 0: return make_response(error_response(pid,async_mode.lower(), action, payload, "Invalid JSON payload", 400)) else: return make_response(error_response(pid,async_mode.lower(), action, payload, "the method could not be implemented", 400)) - if ark_id.startswith("0x"): - pid = dark_map.get_pid_by_hash(ark_id) - else: - pid = dark_map.get_pid_by_ark(ark_id) - tx_set = dark_map.async_set_payload(pid.pid_hash, payload) tx_status, tx_recipt = dark_gw.transaction_was_executed(tx_set) diff --git a/app/util/synchronous.py b/app/util/synchronous.py index 84d4f99..57f09d5 100644 --- a/app/util/synchronous.py +++ b/app/util/synchronous.py @@ -126,11 +126,17 @@ def set_payload(ark_id, payload): action = "set_payload" pid = None - if VERIFICATION_METHOD == "BASIC": - payload = json.loads(payload) + if ark_id.startswith("0x"): + pid = dark_map.get_pid_by_hash(ark_id) + else: + pid = dark_map.get_pid_by_ark(ark_id) - if type(payload) != dict or len(payload) == 0: - return error_response(pid,async_mode.lower(), action, payload, "Invalid JSON payload", 400) + if VERIFICATION_METHOD == "BASIC": + if type(payload) != dict: + try: + payload = json.loads(payload) + except Exception as e: + return error_response(pid,async_mode.lower(), action, payload, "Invalid JSON payload", 400) elif VERIFICATION_METHOD == "NONE" or VERIFICATION_METHOD == None: if type(payload) != dict or len(payload) == 0: @@ -138,11 +144,6 @@ def set_payload(ark_id, payload): else: return error_response(pid,async_mode.lower(), action, payload, "the method could not be implemented", 400) - if ark_id.startswith("0x"): - pid = dark_map.get_pid_by_hash(ark_id) - else: - pid = dark_map.get_pid_by_ark(ark_id) - dark_map.sync_set_payload(pid.pid_hash, payload) response = success_response(pid, async_mode.lower(), action, payload,"executed") From 5ca83481ea2a23751cdc47979e02c88d692cf807 Mon Sep 17 00:00:00 2001 From: Francileudo Oliveira Date: Mon, 16 Oct 2023 15:16:25 -0300 Subject: [PATCH 11/11] test: creation of method validation tests --- tests/unit/tests_validation_methods.py | 108 ++++++++++++++++++------- 1 file changed, 78 insertions(+), 30 deletions(-) diff --git a/tests/unit/tests_validation_methods.py b/tests/unit/tests_validation_methods.py index 65f8e80..de9e7e7 100644 --- a/tests/unit/tests_validation_methods.py +++ b/tests/unit/tests_validation_methods.py @@ -1,41 +1,89 @@ import pytest -from flask import jsonify +import json from app.util.validation import ValidationUtil -from app.util.config_manager import ConfigManager +# external url validation tests -config_manager = ConfigManager() +def test_add_url_valid(): + url = "http://www.hyperdrive.com/123456" + assert ValidationUtil.check_url(url) is True -# tests for synchronous external url addition method +def test_add_url_invalid(): -def mock_add_url(VERIFICATION_METHOD, external_url): - try: - # Simulates URL validation behavior - if VERIFICATION_METHOD == "BASIC": - if ValidationUtil.check_url(external_url) == False: - return {"status": "error", "message": "invalid url"}, 400 - elif VERIFICATION_METHOD == "NONE" or VERIFICATION_METHOD == None: - if len(external_url) == 0: - return {"status": "error", "message": "invalid url"}, 400 - else: - return {"status": "error", "message": "the method could not be implemented"}, 400 + url = "hello 123" + assert ValidationUtil.check_url(url) is False - # Simulates a successful response - return {"status": "success", "message": "executed"}, 200 +def test_add_empty_url(): - except Exception as e: - # Simulates a generic error response - return jsonify({"error": str(e)}), 400 + url = "" + assert ValidationUtil.check_url(url) is False -def test_add_url_valid(): - config_manager.set_url_validation("BASIC") - VERIFICATION_METHOD = config_manager.get_url_validation() - result = mock_add_url(VERIFICATION_METHOD, "http://www.uol.com/123456") - assert 200 in result +def test_check_url_invalid_none(): -def test_add_url_invalid(): - config_manager.set_url_validation("BASIC") - VERIFICATION_METHOD = config_manager.get_url_validation() - result = mock_add_url(VERIFICATION_METHOD, "hello 123") - assert 400 in result + url = None + assert ValidationUtil.check_url(url) is False + +# external pid validation tests + +def mock_validation_pid(external_pid): + + if external_pid.startswith("doi:/"): + valid_pid = external_pid.split(":/")[1] + return valid_pid + else: + return False + +def test_mock_validation_pid_valid_pid(): + + external_pid = "doi:/116.jdakt.7892" + result = mock_validation_pid(external_pid) + assert result == "116.jdakt.7892" + +def test_mock_validation_pid_invalid_pid(): + + external_pid = "DOIXPTO" + result = mock_validation_pid(external_pid) + assert result is False + +def test_mock_validation_pid_empty_pid(): + + external_pid = "" + result = mock_validation_pid(external_pid) + assert result is False + +# payload validation tests +def mock_validation_payload(payload): + + if type(payload) != dict: + try: + payload = json.loads(payload) + return payload + except Exception: + return False + else: + return payload + +def test_mock_validation_payload_valid_dict(): + + payload = {"key": "value", "number": 42} + result = mock_validation_payload(payload) + assert result == payload + +def test_mock_validation_payload_valid_json_str(): + + payload_str = '{"key": "value", "number": 42}' + result = mock_validation_payload(payload_str) + assert result == json.loads(payload_str) + +def test_mock_validation_payload_invalid_json_str(): + + payload_str = "{x : y}" + result = mock_validation_payload(payload_str) + assert result is False + +def test_mock_validation_payload_invalid_type(): + + payload = 123 + result = mock_validation_payload(payload) + assert result is False