From 8a76d147a79d9bfba7f9130ddd9c16ca98f482b7 Mon Sep 17 00:00:00 2001 From: smileknife Date: Wed, 21 Oct 2020 19:47:10 +0800 Subject: [PATCH] dependInfo --- advisors/review_tool.py | 2 +- .../application/apps/dependinfo/serialize.py | 155 +++++++++++ .../application/apps/dependinfo/url.py | 8 +- .../application/apps/dependinfo/view.py | 250 +++++++++++++++++- .../dependinfo_build_depend.json | 94 +++++++ .../dependinfo_install_depend.json | 170 ++++++++++++ packageship/test/read_test.py | 5 +- .../test_dependinfo_build_depend.py | 161 +++++++++++ .../test_dependinfo_install_depend.py | 164 ++++++++++++ 9 files changed, 997 insertions(+), 12 deletions(-) create mode 100644 packageship/packageship/application/apps/dependinfo/serialize.py create mode 100644 packageship/test/common_files/correct_test_result_json/dependinfo_build_depend.json create mode 100644 packageship/test/common_files/correct_test_result_json/dependinfo_install_depend.json create mode 100644 packageship/test/test_module/dependinfo_tests/test_dependinfo_build_depend.py create mode 100644 packageship/test/test_module/dependinfo_tests/test_dependinfo_install_depend.py diff --git a/advisors/review_tool.py b/advisors/review_tool.py index 78c21865..b528303d 100755 --- a/advisors/review_tool.py +++ b/advisors/review_tool.py @@ -409,7 +409,7 @@ def basic_review(cklist, branch): if not check_spec_change(branch, "License"): continue elif value2['condition'] == 'version-change': - if not check_spec_change(branch, "Version"): + if branch == "master" or not check_spec_change(branch, "Version"): continue item = join_check_item(categorizer[key1], value2['claim'], value2['explain']) diff --git a/packageship/packageship/application/apps/dependinfo/serialize.py b/packageship/packageship/application/apps/dependinfo/serialize.py new file mode 100644 index 00000000..a5fdcc30 --- /dev/null +++ b/packageship/packageship/application/apps/dependinfo/serialize.py @@ -0,0 +1,155 @@ +#!/usr/bin/python3 +""" +Description: marshmallow serialize +""" +from marshmallow import Schema +from marshmallow import fields +from marshmallow import ValidationError +from marshmallow import validate + + +class InstallDependSchema(Schema): + """ + Description: InstallDependSchema + """ + binaryName = fields.Str( + required=True, + validate=validate.Length( + min=1, max=500)) + db_list = fields.List(fields.String(), required=False, allow_none=True) + + +class BuildDependSchema(Schema): + """ + Description: BuildDependSchema serialize + """ + sourceName = fields.Str( + required=True, + validate=validate.Length( + min=1, max=200)) + db_list = fields.List(fields.String(), required=False, allow_none=True) + + +def validate_withsubpack(withsubpack): + """ + Description: Method test + Args： + withsubpack: withsubpack + Returns: + True or failure + Raises: + ValidationError: Test failed + """ + if withsubpack not in ['0', '1']: + raise ValidationError("withSubpack is illegal data ") + + +class BeDependSchema(Schema): + """ + Description: BeDependSchema serialize + """ + packagename = fields.Str( + required=True, + validate=validate.Length( + min=1, + max=200)) + withsubpack = fields.Str( + validate=validate_withsubpack, + required=False, allow_none=True) + dbname = fields.Str( + required=True, + validate=validate.Length( + min=1, + max=50)) + + +def validate_selfbuild(selfbuild): + """ + Description: Method test + """ + if selfbuild not in ['0', '1']: + raise ValidationError("selfbuild is illegal data ") + + +def validate_packtype(packagetype): + """ + Description: Method test + """ + if packagetype not in ['source', 'binary']: + raise ValidationError("packtype is illegal data ") + + +class SelfDependSchema(Schema): + """ + Description: SelfDependSchema serialize + """ + packagename = fields.Str( + required=True, + validate=validate.Length( + min=1, + max=200)) + db_list = fields.List(fields.String(), required=False, allow_none=True) + selfbuild = fields.Str(validate=validate_selfbuild, + required=False, allow_none=True) + withsubpack = fields.Str( + validate=validate_withsubpack, required=False, allow_none=True) + packtype = fields.Str(validate=validate_packtype, + required=False, allow_none=True) + + +def validate_query_type(query_type): + """ + Description: Method test + Args： + query_type: query_type + Returns: + True or failure + Raises: + ValidationError: Test failed + """ + if query_type not in ['installdep', 'builddep', 'selfbuild', 'bedepend']: + raise ValidationError("query_type is illegal data ") + + +class SingleGraphSchema(Schema): + """ + Description: SingleGraphSchema serialize + """ + packagename = fields.Str( + required=True, + validate=validate.Length( + min=1, + max=200)) + + dbname = fields.List(fields.String(), required=False, allow_none=True) + + query_type = fields.Str( + required=True, allow_none=True, + validate=validate_query_type) + + selfbuild = fields.Str(validate=validate_selfbuild, + required=False, allow_none=True) + + withsubpack = fields.Str( + validate=validate_withsubpack, required=False, allow_none=True) + + packagetype = fields.Str(validate=validate_packtype, required=False, allow_none=True) + + node_name = fields.Str( + required=True, + validate=validate.Length( + min=1, + max=50)) + + +def have_err_db_name(db_list, db_priority): + """ + Description: have error database name method + Args: + db_list: db_list db list of inputs + db_priority: db_priority default list + Returns: + If any element in db_list is no longer in db_priority, return false + Raises: + """ + return any(filter(lambda db_name: db_name not in db_priority, db_list)) diff --git a/packageship/packageship/application/apps/dependinfo/url.py b/packageship/packageship/application/apps/dependinfo/url.py index cffc61f0..e6f0cf0e 100644 --- a/packageship/packageship/application/apps/dependinfo/url.py +++ b/packageship/packageship/application/apps/dependinfo/url.py @@ -19,5 +19,11 @@ urls = [ # get BeDepend (view.InfoBeDepend, '/dependInfo/beDepend', {'query': ('POST')}), # get all database name - (view.DataBaseInfo, '/dependInfo/databases', {'query': ('GET')}) + (view.DataBaseInfo, '/dependInfo/databases', {'query': ('GET')}), + # get InstallDepend + (view.InfoInstallDepend, '/dependInfo/installDepend', {'query': ('POST')}), + # get BuildDepend + (view.InfoBuildDepend, '/dependInfo/buildDepend', {'query': ('POST')}), + # get SingleGraph + (view.SingleGraph, '/dependInfo/result/singleGraph', {'query': ('POST')}), ] diff --git a/packageship/packageship/application/apps/dependinfo/view.py b/packageship/packageship/application/apps/dependinfo/view.py index 7b06362c..f7a9263c 100644 --- a/packageship/packageship/application/apps/dependinfo/view.py +++ b/packageship/packageship/application/apps/dependinfo/view.py @@ -19,16 +19,20 @@ from flask import request from flask import jsonify from flask_restful import Resource from packageship.libs.log import Log - -from packageship.application.apps.package.serialize import SelfDependSchema -from packageship.application.apps.package.serialize import BeDependSchema -from packageship.application.apps.package.serialize import have_err_db_name from packageship.application.apps.package.function.constants import ResponseCode from packageship.application.apps.package.function.searchdb import db_priority from packageship.application.apps.package.function.constants import ListNode +from .serialize import SelfDependSchema +from .serialize import BeDependSchema +from .serialize import InstallDependSchema +from .serialize import BuildDependSchema +from .serialize import SingleGraphSchema +from .serialize import have_err_db_name +from .function.graphcache import install_depend +from .function.graphcache import build_depend from .function.graphcache import bedepend from .function.graphcache import self_build as selfbuild - +from .function.singlegraph import BaseGraph DB_NAME = 0 LOGGER = Log(__name__) @@ -50,8 +54,8 @@ class ParseDependPackageMethod(Resource): def _parse_database(self, db_list): data_name = [] - for _, v in enumerate(db_list): - data_name.append({"database": v, "binary_num": 0, "source_num": 0}) + for _, dname in enumerate(db_list): + data_name.append({"database": dname, "binary_num": 0, "source_num": 0}) return data_name # pylint: disable = too-many-nested-blocks @@ -128,8 +132,8 @@ class InfoSelfDepend(ParseDependPackageMethod): if bin_packages: for bin_package, package_depend in bin_packages.items(): # distinguish whether the current data is the data of the root node - if isinstance(package_depend, list) and package_depend[ListNode.PARENT_LIST][DB_NAME][ - DB_NAME] != 'root': + if isinstance(package_depend, list) and \ + package_depend[ListNode.PARENT_LIST][DB_NAME][DB_NAME] != 'root': row_data = {"binary_name": bin_package, "source_name": package_depend[ListNode.SOURCE_NAME], "version": package_depend[ListNode.VERSION], @@ -328,3 +332,231 @@ class DataBaseInfo(Resource): return jsonify( ResponseCode.response_json(ResponseCode.SUCCESS, data=name_list) ) + + +class InfoInstallDepend(ParseDependPackageMethod): + """ + Description: install depend of binary package + Restful API: post + changeLog: + """ + + def post(self): + """ + Query a package's install depend(support + querying in one or more databases) + + Args: + binaryName + dbPreority: the array for database preority + Returns: + resultDict{ + binary_name: //binary package name + [ + src, //the source package name for + that binary packge + dbname, + version, + [ + parent_node, //the binary package name which is + the install depend for binaryName + type //install install or build, which + depend on the function + ] + ] + } + Raises: + """ + schema = InstallDependSchema() + + data = request.get_json() + validate_err = schema.validate(data) + if validate_err: + return jsonify( + ResponseCode.response_json(ResponseCode.PARAM_ERROR) + ) + pkg_name = data.get("binaryName") + + db_pri = db_priority() + if not db_pri: + return jsonify( + ResponseCode.response_json( + ResponseCode.FILE_NOT_FIND_ERROR + ) + ) + + db_list = data.get("db_list") if data.get("db_list") \ + else db_pri + + if not all([pkg_name, db_list]): + return jsonify( + ResponseCode.response_json(ResponseCode.PARAM_ERROR) + ) + + if have_err_db_name(db_list, db_pri): + return jsonify( + ResponseCode.response_json(ResponseCode.DB_NAME_ERROR) + ) + + query_parameter = {"binaryName": pkg_name, + "db_list": db_list} + + result_data = install_depend(query_parameter) + res_code = result_data["code"] + res_dict = result_data["install_dict"] + res_not_found_components = result_data["not_found_components"] + + install_dict = self.parse_depend_package(res_dict, db_list) + if not install_dict: + return jsonify( + ResponseCode.response_json(res_code) + ) + elif len(install_dict) == 1 and install_dict.get(pkg_name)[2] == 'NOT FOUND': + return jsonify( + ResponseCode.response_json(ResponseCode.PACK_NAME_NOT_FOUND) + ) + return jsonify( + ResponseCode.response_json(ResponseCode.SUCCESS, data={ + "install_dict": install_dict, + 'not_found_components': list(res_not_found_components) + }) + ) + + +class InfoBuildDepend(ParseDependPackageMethod): + """ + Description: build depend of binary package + Restful API: post + changeLog: + """ + + def post(self): + """ + Query a package's build depend and + build depend package's install depend + (support querying in one or more databases) + + Args: + sourceName :name of the source package + dbPreority：the array for database preority + Returns: + for + example:: + { + "code": "", + "data": "", + "msg": "" + } + Raises: + """ + schema = BuildDependSchema() + + data = request.get_json() + if schema.validate(data): + return jsonify( + ResponseCode.response_json(ResponseCode.PARAM_ERROR) + ) + pkg_name = data.get("sourceName") + + db_pri = db_priority() + + if not db_pri: + return jsonify( + ResponseCode.response_json( + ResponseCode.FILE_NOT_FIND_ERROR + ) + ) + + db_list = data.get("db_list") if data.get("db_list") \ + else db_pri + + if have_err_db_name(db_list, db_pri): + return jsonify( + ResponseCode.response_json(ResponseCode.DB_NAME_ERROR) + ) + + query_parameter = {"sourceName": pkg_name, + "db_list": db_list} + + result_data = build_depend(query_parameter) + res_code = result_data["code"] + res_dict = result_data["build_dict"] + res_not_found_components = result_data["not_found_components"] + + res_dict = self.parse_depend_package(res_dict, db_list) + if res_dict: + res_code = ResponseCode.SUCCESS + else: + return jsonify( + ResponseCode.response_json( + res_code + ) + ) + + return jsonify( + ResponseCode.response_json( + res_code, + data={ + 'build_dict': res_dict, + 'not_found_components': list(res_not_found_components) + } + ) + ) + + +class SingleGraph(Resource): + """ + Description: Specifies the binary package dependency graph fetch + Restful API: post + changeLog: + """ + + def post(self): + """ + Specifies that the binary package dependency graph gets the interface + + Args: + packagename:The package name, binary package, or source package + dbname:databases name + query_type:The type of data you want to query + selfbuild:Is a self-compiling dependency + withsubpack:Whether the query subpackage query needs to pass this parameter + packagetype:The type of data, mainly source or binary + node_name:The name of the node to be queried + Returns: + for example: + { + "code": "", + "data": "", + "msg": "" + } + Raises: + """ + schema = SingleGraphSchema() + data = request.get_json() + if schema.validate(data): + return jsonify( + ResponseCode.response_json(ResponseCode.PARAM_ERROR) + ) + + db_pri = db_priority() + + if not db_pri: + return jsonify( + ResponseCode.response_json( + ResponseCode.FILE_NOT_FIND_ERROR + ) + ) + + dbname = data.get("dbname") + + if have_err_db_name(dbname, db_pri): + return jsonify( + ResponseCode.response_json(ResponseCode.DB_NAME_ERROR) + ) + + response_status, msg, res_data = BaseGraph(**data).parse_depend_graph() + + res_dict = {"code": response_status, "data": res_data, "msg": msg} + + return jsonify(res_dict) diff --git a/packageship/test/common_files/correct_test_result_json/dependinfo_build_depend.json b/packageship/test/common_files/correct_test_result_json/dependinfo_build_depend.json new file mode 100644 index 00000000..945d58fa --- /dev/null +++ b/packageship/test/common_files/correct_test_result_json/dependinfo_build_depend.json @@ -0,0 +1,94 @@ +[ + { + "input": { + "sourceName": "A" + }, + "output": { + "code": "2001", + "data": { + "build_dict": { + "A_src": [ + "source", + "0.0.23b", + "mainline", + [ + [ + "root", + null + ] + ] + ], + "B1": [ + "B", + "0.0.2", + "mainline", + [ + [ + "A", + "build" + ] + ] + ], + "C1": [ + "C", + "0.1", + "mainline", + [ + [ + "A", + "build" + ], + [ + "A2", + "install" + ] + ] + ], + "A1": [ + "A", + "0.0.23b", + "mainline", + [ + [ + "B1", + "install" + ], + [ + "D1", + "install" + ] + ] + ], + "A2": [ + "A", + "0.0.23b", + "mainline", + [ + [ + "A1", + "install" + ], + [ + "C1", + "install" + ] + ] + ], + "D1": [ + "D", + "0.11", + "mainline", + [ + [ + "A2", + "install" + ] + ] + ] + }, + "not_found_components": [] + }, + "msg": "Successful Operation!" + } + } +] \ No newline at end of file diff --git a/packageship/test/common_files/correct_test_result_json/dependinfo_install_depend.json b/packageship/test/common_files/correct_test_result_json/dependinfo_install_depend.json new file mode 100644 index 00000000..34d09821 --- /dev/null +++ b/packageship/test/common_files/correct_test_result_json/dependinfo_install_depend.json @@ -0,0 +1,170 @@ +[ + { + "input": { + "binaryName": "A1" + }, + "output": { + "code": "2001", + "data": { + "install_dict": { + "A1": [ + "A", + "0.0.23b", + "mainline", + [ + [ + "root", + null + ], + [ + "D1", + "install" + ] + ] + ], + "A2": [ + "A", + "0.0.23b", + "mainline", + [ + [ + "A1", + "install" + ], + [ + "C1", + "install" + ] + ] + ], + "C1": [ + "C", + "0.1", + "mainline", + [ + [ + "A2", + "install" + ] + ] + ], + "D1": [ + "D", + "0.11", + "mainline", + [ + [ + "A2", + "install" + ] + ] + ] + }, + "not_found_components": [] + }, + "msg": "Successful Operation!" + } + }, + { + "input": { + "binaryName": "D2" + }, + "output": { + "code": "2001", + "data": { + "install_dict": { + "A1": [ + "A", + "0.0.23b", + "mainline", + [ + [ + "D1", + "install" + ] + ] + ], + "A2": [ + "A", + "0.0.23b", + "mainline", + [ + [ + "A1", + "install" + ], + [ + "C1", + "install" + ] + ] + ], + "C1": [ + "C", + "0.1", + "mainline", + [ + [ + "A2", + "install" + ] + ] + ], + "D1": [ + "D", + "0.11", + "mainline", + [ + [ + "D2", + "install" + ], + [ + "A2", + "install" + ] + ] + ], + "D2": [ + "D", + "0.11", + "mainline", + [ + [ + "root", + null + ] + ] + ] + }, + "not_found_components": [] + }, + "msg": "Successful Operation!" + } + }, + { + "input": { + "binaryName": "C2" + }, + "output": { + "code": "2001", + "data": { + "install_dict": { + "C2": [ + "C", + "0.1", + "mainline", + [ + [ + "root", + null + ] + ] + ] + }, + "not_found_components": [] + }, + "msg": "Successful Operation!" + } + } +] \ No newline at end of file diff --git a/packageship/test/read_test.py b/packageship/test/read_test.py index 709986b8..0c3d6c46 100644 --- a/packageship/test/read_test.py +++ b/packageship/test/read_test.py @@ -17,6 +17,8 @@ def read_data_tests(): from test.test_module.lifecycle.test_maintainer import TestGetMaintainers from test.test_module.lifecycle.test_downloadexcel import TestDownloadExcelFile from test.test_module.lifecycle.test_get_issues import TestGetIssue + from test.test_module.dependinfo_tests.test_dependinfo_install_depend import TestDependInfoInstallDepend + from test.test_module.dependinfo_tests.test_dependinfo_build_depend import TestDependInfoBuildDepend from test.test_module.dependinfo_tests.test_dependinfo_self_depend import TestDependInfoSelfDepend from test.test_module.dependinfo_tests.test_dependinfo_be_depend import TestDependInfoBeDepend @@ -25,7 +27,8 @@ def read_data_tests(): classes = [TestInstallDepend, TestSelfDepend, TestBeDepend, TestGetRepodatas, TestBuildDepend, TestPackages, TestGetSinglePack, TestGetMaintainers, TestDownloadExcelFile, - TestGetIssue, TestDependInfoBeDepend, TestDependInfoSelfDepend] + TestGetIssue, TestDependInfoBeDepend, TestDependInfoSelfDepend, + TestDependInfoInstallDepend, TestDependInfoBuildDepend] for cls in classes: suite.addTests(unittest.TestLoader().loadTestsFromTestCase(cls)) return RUNNER.run(suite) diff --git a/packageship/test/test_module/dependinfo_tests/test_dependinfo_build_depend.py b/packageship/test/test_module/dependinfo_tests/test_dependinfo_build_depend.py new file mode 100644 index 00000000..43b586a8 --- /dev/null +++ b/packageship/test/test_module/dependinfo_tests/test_dependinfo_build_depend.py @@ -0,0 +1,161 @@ +#!/usr/bin/python3 +# -*- coding:utf-8 -*- +""" + build_depend unittest +""" +import json +import unittest + +from test.base_code.read_data_base import ReadTestBase +from test.base_code.common_test_code import compare_two_values, get_correct_json_by_filename +from packageship.application.apps.package.function.constants import ResponseCode + + +class TestDependInfoBuildDepend(ReadTestBase): + """ + class for test build_depend + """ + + def test_empty_source_name_dblist(self): + """ + test empty parameters:sourceName,dbList + :return: + """ + resp = self.client.post("/packages/findBuildDepend", + data="{}", + content_type="application/json") + resp_dict = json.loads(resp.data) + + self.assertIn("code", resp_dict, msg="Error in data format return") + self.assertEqual(ResponseCode.PARAM_ERROR, + resp_dict.get("code"), + msg="Error in status code return") + + self.assertIn("msg", resp_dict, msg="Error in data format return") + self.assertEqual(ResponseCode.CODE_MSG_MAP.get(ResponseCode.PARAM_ERROR), + resp_dict.get("msg"), + msg="Error in status prompt return") + + self.assertIn("data", resp_dict, msg="Error in data format return") + self.assertIsNone(resp_dict.get("data"), msg="Error in data information return") + + resp = self.client.post("/packages/findBuildDepend", + data=json.dumps({"sourceName": "A"}), + content_type="application/json") + + resp_dict = json.loads(resp.data) + self.assertIn("code", resp_dict, msg="Error in data format return") + self.assertEqual(ResponseCode.SUCCESS, + resp_dict.get("code"), + msg="Error in status code return") + + self.assertIn("msg", resp_dict, msg="Error in data format return") + self.assertEqual(ResponseCode.CODE_MSG_MAP.get(ResponseCode.SUCCESS), + resp_dict.get("msg"), + msg="Error in status prompt return") + + self.assertIn("data", resp_dict, msg="Error in data format return") + self.assertIsNotNone(resp_dict.get("data"), msg="Error in data information return") + + def test_wrong_source_name_dblist(self): + """ + test wrong parameters:sourceName,dbList + :return: None + """ + resp = self.client.post("/packages/findBuildDepend", + data=json.dumps({"sourceName": 0}), + content_type="application/json") + resp_dict = json.loads(resp.data) + + self.assertIn("code", resp_dict, msg="Error in data format return") + self.assertEqual(ResponseCode.PARAM_ERROR, + resp_dict.get("code"), + msg="Error in status code return") + + self.assertIn("msg", resp_dict, msg="Error in data format return") + self.assertEqual(ResponseCode.CODE_MSG_MAP.get(ResponseCode.PARAM_ERROR), + resp_dict.get("msg"), + msg="Error in status prompt return") + + self.assertIn("data", resp_dict, msg="Error in data format return") + self.assertIsNone(resp_dict.get("data"), msg="Error in data information return") + + resp = self.client.post("/packages/findBuildDepend", + data=json.dumps({"sourceName": "qitiandasheng"}), + content_type="application/json") + + resp_dict = json.loads(resp.data) + self.assertIn("code", resp_dict, msg="Error in data format return") + self.assertEqual(ResponseCode.PACK_NAME_NOT_FOUND, + resp_dict.get("code"), + msg="Error in status code return") + + self.assertIn("msg", resp_dict, msg="Error in data format return") + self.assertEqual(ResponseCode.CODE_MSG_MAP.get(ResponseCode.PACK_NAME_NOT_FOUND), + resp_dict.get("msg"), + msg="Error in status prompt return") + + self.assertIn("data", resp_dict, msg="Error in data format return") + self.assertIsNone(resp_dict.get("data"), msg="Error in data information return") + + resp = self.client.post("/packages/findBuildDepend", + data=json.dumps({"sourceName": "CUnit", + "db_list": [12, 3, 4]}), + content_type="application/json") + resp_dict = json.loads(resp.data) + + self.assertIn("code", resp_dict, msg="Error in data format return") + self.assertEqual(ResponseCode.PARAM_ERROR, + resp_dict.get("code"), + msg="Error in status code return") + + self.assertIn("msg", resp_dict, msg="Error in data format return") + self.assertEqual(ResponseCode.CODE_MSG_MAP.get(ResponseCode.PARAM_ERROR), + resp_dict.get("msg"), + msg="Error in status prompt return") + + self.assertIn("data", resp_dict, msg="Error in data format return") + self.assertIsNone(resp_dict.get("data"), msg="Error in data information return") + + resp = self.client.post("/packages/findBuildDepend", + data=json.dumps({"sourceName": "CUnit", + "db_list": ["shifu", "bajie"] + }), content_type="application/json") + resp_dict = json.loads(resp.data) + + self.assertIn("code", resp_dict, msg="Error in data format return") + self.assertEqual(ResponseCode.DB_NAME_ERROR, + resp_dict.get("code"), + msg="Error in status code return") + + self.assertIn("msg", resp_dict, msg="Error in data format return") + self.assertEqual(ResponseCode.CODE_MSG_MAP.get(ResponseCode.DB_NAME_ERROR), + resp_dict.get("msg"), + msg="Error in status prompt return") + + self.assertIn("data", resp_dict, msg="Error in data format return") + self.assertIsNone(resp_dict.get("data"), msg="Error in data information return") + + def test_true_params_result(self): + """ + test_true_params_result + Returns: + + """ + correct_list = get_correct_json_by_filename("build_depend") + + self.assertNotEqual([], correct_list, msg="Error reading JSON file") + + for correct_data in correct_list: + input_value = correct_data["input"] + resp = self.client.post("/packages/findBuildDepend", + data=json.dumps(input_value), + content_type="application/json") + output_for_input = correct_data["output"] + resp_dict = json.loads(resp.data) + self.assertTrue(compare_two_values(output_for_input, resp_dict), + msg="The answer is not correct") + + +if __name__ == '__main__': + unittest.main() diff --git a/packageship/test/test_module/dependinfo_tests/test_dependinfo_install_depend.py b/packageship/test/test_module/dependinfo_tests/test_dependinfo_install_depend.py new file mode 100644 index 00000000..0cefa42f --- /dev/null +++ b/packageship/test/test_module/dependinfo_tests/test_dependinfo_install_depend.py @@ -0,0 +1,164 @@ +#!/usr/bin/python3 +# -*- coding:utf-8 -*- +""" +TestInstallDepend +""" +import unittest +import json + +from test.base_code.common_test_code import get_correct_json_by_filename, compare_two_values +from test.base_code.read_data_base import ReadTestBase +from packageship.application.apps.package.function.constants import ResponseCode + + +class TestDependInfoInstallDepend(ReadTestBase): + """ + TestInstallDepend + """ + + def test_empty_binaryName_dbList(self): + """ + test_empty_binaryName_dbList + Returns: + + """ + resp = self.client.post("/packages/findInstallDepend", + data="{}", + content_type="application/json") + resp_dict = json.loads(resp.data) + + self.assertIn("code", resp_dict, msg="Error in data format return") + self.assertEqual(ResponseCode.PARAM_ERROR, + resp_dict.get("code"), + msg="Error in status code return") + + self.assertIn("msg", resp_dict, msg="Error in data format return") + self.assertEqual(ResponseCode.CODE_MSG_MAP.get(ResponseCode.PARAM_ERROR), + resp_dict.get("msg"), + msg="Error in status prompt return") + + self.assertIn("data", resp_dict, msg="Error in data format return") + self.assertIsNone(resp_dict.get("data"), msg="Error in data information return") + + resp = self.client.post("/packages/findInstallDepend", + data=json.dumps({"binaryName": "A1"}), + content_type="application/json") + + resp_dict = json.loads(resp.data) + self.assertIn("code", resp_dict, msg="Error in data format return") + self.assertEqual(ResponseCode.SUCCESS, + resp_dict.get("code"), + msg="Error in status code return") + + self.assertIn("msg", resp_dict, msg="Error in data format return") + self.assertEqual(ResponseCode.CODE_MSG_MAP.get(ResponseCode.SUCCESS), + resp_dict.get("msg"), + msg="Error in status prompt return") + + self.assertIn("data", resp_dict, msg="Error in data format return") + self.assertIsNotNone(resp_dict.get("data"), msg="Error in data information return") + + def test_wrong_binaryName_dbList(self): + """ + test_empty_binaryName_dbList + Returns: + + """ + resp = self.client.post("/packages/findInstallDepend", + data=json.dumps({"binaryName": 0}), + content_type="application/json") + resp_dict = json.loads(resp.data) + + self.assertIn("code", resp_dict, msg="Error in data format return") + self.assertEqual(ResponseCode.PARAM_ERROR, + resp_dict.get("code"), + msg="Error in status code return") + + self.assertIn("msg", resp_dict, msg="Error in data format return") + self.assertEqual(ResponseCode.CODE_MSG_MAP.get(ResponseCode.PARAM_ERROR), + resp_dict.get("msg"), + msg="Error in status prompt return") + + self.assertIn("data", resp_dict, msg="Error in data format return") + self.assertIsNone(resp_dict.get("data"), msg="Error in data information return") + + resp = self.client.post("/packages/findInstallDepend", + data=json.dumps( + {"binaryName": "qitiandasheng"}), + content_type="application/json") + + resp_dict = json.loads(resp.data) + self.assertIn("code", resp_dict, msg="Error in data format return") + self.assertEqual(ResponseCode.PACK_NAME_NOT_FOUND, + resp_dict.get("code"), + msg="Error in status code return") + + self.assertIn("msg", resp_dict, msg="Error in data format return") + self.assertEqual(ResponseCode.CODE_MSG_MAP.get(ResponseCode.PACK_NAME_NOT_FOUND), + resp_dict.get("msg"), + msg="Error in status prompt return") + + self.assertIn("data", resp_dict, msg="Error in data format return") + self.assertIsNone(resp_dict.get("data"), msg="Error in data information return") + + resp = self.client.post("/packages/findInstallDepend", + data=json.dumps({"binaryName": "A1", + "db_list": [12, 3, 4]}), + content_type="application/json") + resp_dict = json.loads(resp.data) + + self.assertIn("code", resp_dict, msg="Error in data format return") + self.assertEqual(ResponseCode.PARAM_ERROR, + resp_dict.get("code"), + msg="Error in status code return") + + self.assertIn("msg", resp_dict, msg="Error in data format return") + self.assertEqual(ResponseCode.CODE_MSG_MAP.get(ResponseCode.PARAM_ERROR), + resp_dict.get("msg"), + msg="Error in status prompt return") + + self.assertIn("data", resp_dict, msg="Error in data format return") + self.assertIsNone(resp_dict.get("data"), msg="Error in data information return") + + resp = self.client.post("/packages/findInstallDepend", + data=json.dumps({"binaryName": "A1", + "db_list": ["shifu", "bajie"] + }), content_type="application/json") + resp_dict = json.loads(resp.data) + + self.assertIn("code", resp_dict, msg="Error in data format return") + self.assertEqual(ResponseCode.DB_NAME_ERROR, + resp_dict.get("code"), + msg="Error in status code return") + + self.assertIn("msg", resp_dict, msg="Error in data format return") + self.assertEqual(ResponseCode.CODE_MSG_MAP.get(ResponseCode.DB_NAME_ERROR), + resp_dict.get("msg"), + msg="Error in status prompt return") + + self.assertIn("data", resp_dict, msg="Error in data format return") + self.assertIsNone(resp_dict.get("data"), msg="Error in data information return") + + def test_true_params_result(self): + """ + test_empty_binaryName_dbList + Returns: + + """ + correct_list = get_correct_json_by_filename("install_depend") + + self.assertNotEqual([], correct_list, msg="Error reading JSON file") + + for correct_data in correct_list: + input_value = correct_data["input"] + resp = self.client.post("/packages/findInstallDepend", + data=json.dumps(input_value), + content_type="application/json") + output_for_input = correct_data["output"] + resp_dict = json.loads(resp.data) + self.assertTrue(compare_two_values(output_for_input, resp_dict), + msg="The answer is not correct") + + +if __name__ == '__main__': + unittest.main() -- Gitee