diff --git a/packageship/packageship/application/apps/dependinfo/url.py b/packageship/packageship/application/apps/dependinfo/url.py index 47dfb37733706a96402a9d38edf921f1531a0580..cffc61f0813a42241dc68d96308c3c43ebe21573 100644 --- a/packageship/packageship/application/apps/dependinfo/url.py +++ b/packageship/packageship/application/apps/dependinfo/url.py @@ -14,6 +14,10 @@ from . import view urls = [ + # get SelfDepend + (view.InfoSelfDepend, '/dependInfo/selfDepend', {'query': ('POST')}), + # get BeDepend + (view.InfoBeDepend, '/dependInfo/beDepend', {'query': ('POST')}), # get all database name (view.DataBaseInfo, '/dependInfo/databases', {'query': ('GET')}) ] diff --git a/packageship/packageship/application/apps/dependinfo/view.py b/packageship/packageship/application/apps/dependinfo/view.py index 62b2e587f5655cc044df9156ff282cfc51cc80d9..7b06362c6fe8ae19d58cd81071a2fba28aaf054b 100644 --- a/packageship/packageship/application/apps/dependinfo/view.py +++ b/packageship/packageship/application/apps/dependinfo/view.py @@ -10,11 +10,305 @@ # PURPOSE. # See the Mulan PSL v2 for more details. # ******************************************************************************/ +""" +description: Interface processing +class: BeDepend, BuildDepend, InitSystem, InstallDepend, Packages, +Repodatas, SelfDepend, SinglePack +""" +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 .function.graphcache import bedepend +from .function.graphcache import self_build as selfbuild + +DB_NAME = 0 +LOGGER = Log(__name__) + + +# pylint: disable = no-self-use +# pylint: disable = too-many-locals + +# licensed under the Mulan PSL v2. +class ParseDependPackageMethod(Resource): + """ + Description: Common Method + """ + + def __init__(self): + """ + Description: Class instance initialization + """ + self.statistics = dict() + + 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}) + return data_name + + # pylint: disable = too-many-nested-blocks + def parse_depend_package(self, package_all, db_list=None): + """ + Description: Parsing package data with dependencies + Args: + package_all: http request response content + Returns: + Summarized data table + Raises: + """ + depend_bin_data = [] + depend_src_data = [] + statistics = self._parse_database(db_list) + if isinstance(package_all, dict): + for bin_package, package_depend in package_all.items(): + if isinstance(package_depend, list) and \ + package_depend[ListNode.SOURCE_NAME] != 'source': + row_data = {"binary_name": bin_package, + "source_name": package_depend[ListNode.SOURCE_NAME], + "version": package_depend[ListNode.VERSION], + "database": package_depend[ListNode.DBNAME]} + row_src_data = {"source_name": package_depend[ListNode.SOURCE_NAME], + "version": package_depend[ListNode.VERSION], + "database": package_depend[ListNode.DBNAME]} + if package_depend[ListNode.DBNAME] not in self.statistics: + self.statistics[package_depend[ListNode.DBNAME]] = { + 'binary': [], + 'source': [] + } + if bin_package not in \ + self.statistics[package_depend[ListNode.DBNAME]]['binary']: + self.statistics[package_depend[ListNode.DBNAME]]['binary'].append( + bin_package) + for con in statistics: + if package_depend[ListNode.DBNAME] == con["database"]: + con["binary_num"] += 1 + if package_depend[ListNode.SOURCE_NAME] not in \ + self.statistics[package_depend[ListNode.DBNAME]]['source']: + self.statistics[package_depend[ListNode.DBNAME]]['source'].append( + package_depend[ListNode.SOURCE_NAME]) + for con in statistics: + if package_depend[ListNode.DBNAME] == con["database"]: + con["source_num"] += 1 + depend_bin_data.append(row_data) + depend_src_data.append(row_src_data) + src_data = [dict(t) for t in set([tuple(d.items()) for d in depend_src_data])] + statistics_table = { + "binary_dicts": depend_bin_data, + "source_dicts": src_data, + "statistics": statistics} + return statistics_table + + +class InfoSelfDepend(ParseDependPackageMethod): + """ + Description: querying install and build depend for a package + and others which has the same src name + Restful API: post + changeLog: + """ + + def _parse_bin_package(self, bin_packages, db_list): + """ + Description: Parsing binary result data + Args: + bin_packages: Binary package data + Returns: + Raises: + """ + bin_package_data = [] + statistics = self._parse_database(db_list) + 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': + row_data = {"binary_name": bin_package, + "source_name": package_depend[ListNode.SOURCE_NAME], + "version": package_depend[ListNode.VERSION], + "database": package_depend[ListNode.DBNAME]} + for con in statistics: + if package_depend[ListNode.DBNAME] == con["database"]: + con["binary_num"] += 1 + if package_depend[ListNode.DBNAME] not in self.statistics: + self.statistics[package_depend[ListNode.DBNAME]] = { + 'binary': [], + 'source': [] + } + if bin_package not in \ + self.statistics[package_depend[ListNode.DBNAME]]['binary']: + self.statistics[package_depend[ListNode.DBNAME]]['binary'].append( + bin_package) + bin_package_data.append(row_data) + return bin_package_data, statistics + + def _parse_src_package(self, src_packages, db_list): + """ + Description: Source package data analysis + Args: + src_packages: Source package + + Returns: + Source package data + Raises: + + """ + src_package_data = [] + statistics = db_list + if src_packages: + for src_package, package_depend in src_packages.items(): + if isinstance(package_depend, list): + row_data = {"source_name": src_package, + "version": package_depend[ListNode.VERSION], + "database": package_depend[DB_NAME]} + for con in statistics: + if package_depend[DB_NAME] == con["database"]: + con["source_num"] += 1 + if package_depend[DB_NAME] not in self.statistics: + self.statistics[package_depend[DB_NAME]] = { + 'binary': [], + 'source': [] + } + if src_package not in self.statistics[package_depend[DB_NAME]]['source']: + self.statistics[package_depend[DB_NAME]]['source'].append(src_package) + src_package_data.append(row_data) + return src_package_data, statistics + + def post(self): + """ + Query a package's all dependencies including install and build depend + (support quering a binary or source package in one or more databases) + Args: + packageName:package name + packageType: source/binary + selfBuild :0/1 + withSubpack: 0/1 + dbPreority：the array for database preority + Returns: + for + example:: + { + "code": "", + "data": "", + "msg": "" + } + """ + schema = SelfDependSchema() + data = request.get_json() + validate_err = schema.validate(data) + + if validate_err: + return jsonify( + ResponseCode.response_json(ResponseCode.PARAM_ERROR) + ) + pkg_name = data.get("packagename") + 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 + self_build = data.get("selfbuild", 0) + with_sub_pack = data.get("withsubpack", 0) + pack_type = data.get("packtype", "binary") + if have_err_db_name(db_list, db_pri): + return jsonify( + ResponseCode.response_json(ResponseCode.DB_NAME_ERROR) + ) + query_parameter = {"db_list": db_list, + "packagename": pkg_name, + "selfbuild": self_build, + "withsubpack": with_sub_pack, + "packtype": pack_type} + + result_data = selfbuild(query_parameter) + response_code = result_data["code"] + binary_dicts = result_data["binary_dicts"] + source_dicts = result_data["source_dicts"] + if not all([binary_dicts, source_dicts]): + return jsonify( + ResponseCode.response_json(response_code) + ) + bin_package, package_count = self._parse_bin_package(binary_dicts, db_list) + src_package, statistics = self._parse_src_package(source_dicts, package_count) + return jsonify( + ResponseCode.response_json(ResponseCode.SUCCESS, data={ + "binary_dicts": bin_package, + "source_dicts": src_package, + "statistics": statistics + }) + ) + + +class InfoBeDepend(ParseDependPackageMethod): + """ + Description: querying be installed and built depend for a package + and others which has the same src name + Restful API: post + changeLog: + """ + + def post(self): + """ + Query a package's all dependencies including + be installed and built depend + Args: + packageName:package name + withSubpack: 0/1 + dbname:database name + Returns: + for + example:: + resultList[ + restult[ + binaryName: + srcName: + dbName: + type: beinstall or bebuild, which depend on the function + childNode: the binary package name which is the be built/installed + depend for binaryName + ] + ] + """ + schema = BeDependSchema() + data = request.get_json() + validate_err = schema.validate(data) + if validate_err: + return jsonify( + ResponseCode.response_json(ResponseCode.PARAM_ERROR) + ) + package_name = data.get("packagename") + with_sub_pack = data.get("withsubpack") + db_name = data.get("dbname") + if db_name not in db_priority(): + return jsonify( + ResponseCode.response_json(ResponseCode.DB_NAME_ERROR) + ) + query_parameter = {"packagename": package_name, + "withsubpack": with_sub_pack, + "dbname": db_name} + + result_data = bedepend(query_parameter) + res_code = result_data["code"] + res_dict = result_data["bedepend"] + if not res_dict: + return jsonify( + ResponseCode.response_json(res_code) + ) + result_dict = self.parse_depend_package(res_dict, [db_name]) + return jsonify( + ResponseCode.response_json(ResponseCode.SUCCESS, data=result_dict) + ) class DataBaseInfo(Resource): @@ -33,4 +327,4 @@ class DataBaseInfo(Resource): ) return jsonify( ResponseCode.response_json(ResponseCode.SUCCESS, data=name_list) - ) \ No newline at end of file + ) diff --git a/packageship/test/common_files/correct_test_result_json/dependinfo_be_depend.json b/packageship/test/common_files/correct_test_result_json/dependinfo_be_depend.json new file mode 100644 index 0000000000000000000000000000000000000000..f0416fe6553237f2ba528b0f1af7e89d8c4c4d3f --- /dev/null +++ b/packageship/test/common_files/correct_test_result_json/dependinfo_be_depend.json @@ -0,0 +1,81 @@ +[ + { + "input": { + "packagename": "A", + "dbname": "mainline" + }, + "output": { + "code": "2001", + "data": { + "binary_dicts": [ + { + "binary_name": "A1", + "database": "mainline", + "source_name": "A", + "version": "0.0.23b" + }, + { + "binary_name": "A2", + "database": "mainline", + "source_name": "A", + "version": "0.0.23b" + }, + { + "binary_name": "B1", + "database": "mainline", + "source_name": "B", + "version": "0.0.2" + }, + { + "binary_name": "B2", + "database": "mainline", + "source_name": "B", + "version": "0.0.2" + }, + { + "binary_name": "C1", + "database": "mainline", + "source_name": "C", + "version": "0.1" + }, + { + "binary_name": "D1", + "database": "mainline", + "source_name": "D", + "version": "0.11" + } + ], + "source_dicts": [ + { + "database": "mainline", + "source_name": "B", + "version": "0.0.2" + }, + { + "database": "mainline", + "source_name": "A", + "version": "0.0.23b" + }, + { + "database": "mainline", + "source_name": "C", + "version": "0.1" + }, + { + "database": "mainline", + "source_name": "D", + "version": "0.11" + } + ], + "statistics": [ + { + "binary_num": 6, + "database": "mainline", + "source_num": 4 + } + ] + }, + "msg": "Successful Operation!" + } + } +] \ No newline at end of file diff --git a/packageship/test/common_files/correct_test_result_json/dependinfo_self_depend.json b/packageship/test/common_files/correct_test_result_json/dependinfo_self_depend.json new file mode 100644 index 0000000000000000000000000000000000000000..d85050b2ecf611209ba32385260756304fb5040d --- /dev/null +++ b/packageship/test/common_files/correct_test_result_json/dependinfo_self_depend.json @@ -0,0 +1,334 @@ +[ + { + "input": { + "packagename": "A1" + }, + "output": { + "code": "2001", + "data": { + "binary_dicts": [ + { + "binary_name": "A2", + "database": "mainline", + "source_name": "A", + "version": "0.0.23b" + }, + { + "binary_name": "C1", + "database": "mainline", + "source_name": "C", + "version": "0.1" + }, + { + "binary_name": "D1", + "database": "mainline", + "source_name": "D", + "version": "0.11" + }, + { + "binary_name": "B1", + "database": "mainline", + "source_name": "B", + "version": "0.0.2" + }, + { + "binary_name": "B2", + "database": "mainline", + "source_name": "B", + "version": "0.0.2" + } + ], + "source_dicts": [ + { + "database": "mainline", + "source_name": "A", + "version": "0.0.23b" + }, + { + "database": "mainline", + "source_name": "C", + "version": "0.1" + }, + { + "database": "mainline", + "source_name": "D", + "version": "0.11" + }, + { + "database": "mainline", + "source_name": "B", + "version": "0.0.2" + } + ], + "statistics": [ + { + "binary_num": 5, + "database": "mainline", + "source_num": 4 + }, + { + "binary_num": 0, + "database": "fedora30", + "source_num": 0 + } + ] + }, + "msg": "Successful Operation!" + } + }, + { + "input": { + "packagename": "C", + "packtype": "source" + }, + "output": { + "code": "2001", + "data": { + "binary_dicts": [ + { + "binary_name": "A2", + "database": "mainline", + "source_name": "A", + "version": "0.0.23b" + }, + { + "binary_name": "D1", + "database": "mainline", + "source_name": "D", + "version": "0.11" + }, + { + "binary_name": "A1", + "database": "mainline", + "source_name": "A", + "version": "0.0.23b" + }, + { + "binary_name": "B1", + "database": "mainline", + "source_name": "B", + "version": "0.0.2" + }, + { + "binary_name": "B2", + "database": "mainline", + "source_name": "B", + "version": "0.0.2" + } + ], + "source_dicts": [ + { + "database": "mainline", + "source_name": "C", + "version": "0.1" + }, + { + "database": "mainline", + "source_name": "A", + "version": "0.0.23b" + }, + { + "database": "mainline", + "source_name": "D", + "version": "0.11" + }, + { + "database": "mainline", + "source_name": "B", + "version": "0.0.2" + } + ], + "statistics": [ + { + "binary_num": 5, + "database": "mainline", + "source_num": 4 + }, + { + "binary_num": 0, + "database": "fedora30", + "source_num": 0 + } + ] + }, + "msg": "Successful Operation!" + } + }, + { + "input": { + "packagename": "A2", + "selfbuild": "0", + "withsubpack": "1" + }, + "output": { + "code": "2001", + "data": { + "binary_dicts": [ + { + "binary_name": "C1", + "database": "mainline", + "source_name": "C", + "version": "0.1" + }, + { + "binary_name": "D1", + "database": "mainline", + "source_name": "D", + "version": "0.11" + }, + { + "binary_name": "A1", + "database": "mainline", + "source_name": "A", + "version": "0.0.23b" + }, + { + "binary_name": "C2", + "database": "mainline", + "source_name": "C", + "version": "0.1" + }, + { + "binary_name": "D2", + "database": "mainline", + "source_name": "D", + "version": "0.11" + }, + { + "binary_name": "B1", + "database": "mainline", + "source_name": "B", + "version": "0.0.2" + }, + { + "binary_name": "B2", + "database": "mainline", + "source_name": "B", + "version": "0.0.2" + } + ], + "source_dicts": [ + { + "database": "mainline", + "source_name": "A", + "version": "0.0.23b" + }, + { + "database": "mainline", + "source_name": "C", + "version": "0.1" + }, + { + "database": "mainline", + "source_name": "D", + "version": "0.11" + }, + { + "database": "mainline", + "source_name": "B", + "version": "0.0.2" + } + ], + "statistics": [ + { + "binary_num": 7, + "database": "mainline", + "source_num": 4 + }, + { + "binary_num": 0, + "database": "fedora30", + "source_num": 0 + } + ] + }, + "msg": "Successful Operation!" + } + }, + { + "input": { + "packagename": "A", + "selfbuild": "0", + "withsubpack": "1", + "packtype": "source" + }, + "output": { + "code": "2001", + "data": { + "binary_dicts": [ + { + "binary_name": "D1", + "database": "mainline", + "source_name": "D", + "version": "0.11" + }, + { + "binary_name": "C1", + "database": "mainline", + "source_name": "C", + "version": "0.1" + }, + { + "binary_name": "C2", + "database": "mainline", + "source_name": "C", + "version": "0.1" + }, + { + "binary_name": "D2", + "database": "mainline", + "source_name": "D", + "version": "0.11" + }, + { + "binary_name": "B1", + "database": "mainline", + "source_name": "B", + "version": "0.0.2" + }, + { + "binary_name": "B2", + "database": "mainline", + "source_name": "B", + "version": "0.0.2" + } + ], + "source_dicts": [ + { + "database": "mainline", + "source_name": "A", + "version": "0.0.23b" + }, + { + "database": "mainline", + "source_name": "D", + "version": "0.11" + }, + { + "database": "mainline", + "source_name": "C", + "version": "0.1" + }, + { + "database": "mainline", + "source_name": "B", + "version": "0.0.2" + } + ], + "statistics": [ + { + "binary_num": 6, + "database": "mainline", + "source_num": 4 + }, + { + "binary_num": 0, + "database": "fedora30", + "source_num": 0 + } + ] + }, + "msg": "Successful Operation!" + } + } +] \ No newline at end of file diff --git a/packageship/test/read_test.py b/packageship/test/read_test.py index 16eb5b9dd2cc703d982249c1b0356a00109295d0..709986b820371ceaf442bd70a350feba84bb8377 100644 --- a/packageship/test/read_test.py +++ b/packageship/test/read_test.py @@ -17,13 +17,15 @@ 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_self_depend import TestDependInfoSelfDepend + from test.test_module.dependinfo_tests.test_dependinfo_be_depend import TestDependInfoBeDepend suite = unittest.TestSuite() classes = [TestInstallDepend, TestSelfDepend, TestBeDepend, TestGetRepodatas, TestBuildDepend, TestPackages, TestGetSinglePack, TestGetMaintainers, TestDownloadExcelFile, - TestGetIssue] + TestGetIssue, TestDependInfoBeDepend, TestDependInfoSelfDepend] for cls in classes: suite.addTests(unittest.TestLoader().loadTestsFromTestCase(cls)) return RUNNER.run(suite) diff --git a/packageship/test/test_module/dependinfo_tests/__init__.py b/packageship/test/test_module/dependinfo_tests/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/packageship/test/test_module/dependinfo_tests/test_dependinfo_be_depend.py b/packageship/test/test_module/dependinfo_tests/test_dependinfo_be_depend.py new file mode 100644 index 0000000000000000000000000000000000000000..fc9d12b03137afc4280dd5a9f23f1ddc86829956 --- /dev/null +++ b/packageship/test/test_module/dependinfo_tests/test_dependinfo_be_depend.py @@ -0,0 +1,365 @@ +#!/usr/bin/python3 +# -*- coding:utf-8 -*- +""" +Less transmission is always parameter transmission +""" +import unittest +import json +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 +from packageship.application.apps.package.function.searchdb import db_priority + + +class TestDependInfoBeDepend(ReadTestBase): + """ + The dependencies of the package are tested + """ + db_name = db_priority()[0] + + def test_lack_parameter(self): + """ + Less transmission is always parameter transmission + """ + # No arguments passed + resp = self.client.post("/dependInfo/beDepend", + 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 code return") + + self.assertIn("data", resp_dict, msg="Error in data format return") + self.assertIsNone( + resp_dict.get("data"), + msg="Error in data information return") + + # Only the packagename + resp = self.client.post("/dependInfo/beDepend", + data=json.dumps({ + "packagename": "CUnit", + }), + 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 code return") + + self.assertIn("data", resp_dict, msg="Error in data format return") + self.assertIsNone( + resp_dict.get("data"), + msg="Error in data information return") + + # Only the withsubpack + resp = self.client.post("/dependInfo/beDepend", + data=json.dumps({ + "withsubpack": "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 code return") + + self.assertIn("data", resp_dict, msg="Error in data format return") + self.assertIsNone( + resp_dict.get("data"), + msg="Error in data information return") + + # Only the dbname + resp = self.client.post("/dependInfo/beDepend", + data=json.dumps({ + "dbname": f"{self.db_name}", + }), + 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 code return") + + self.assertIn("data", resp_dict, msg="Error in data format return") + self.assertIsNone( + resp_dict.get("data"), + msg="Error in data information return") + + # Don't preach withsubpack + resp = self.client.post("/dependInfo/beDepend", + data=json.dumps({ + "packagename": "A", + "dbname": f"{self.db_name}" + }), + 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 code return") + + self.assertIn("data", resp_dict, msg="Error in data format return") + self.assertIsNotNone( + resp_dict.get("data"), + msg="Error in data information return") + + # Don't preach dbname + resp = self.client.post("/dependInfo/beDepend", + data=json.dumps({ + "packagename": "CUnit", + "withsubpack": "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 code return") + + self.assertIn("data", resp_dict, msg="Error in data format return") + self.assertIsNone( + resp_dict.get("data"), + msg="Error in data information return") + + # Don't preach packagename + resp = self.client.post("/dependInfo/beDepend", + data=json.dumps({ + "dbname": f"{self.db_name}", + "withsubpack": "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 code return") + + self.assertIn("data", resp_dict, msg="Error in data format return") + self.assertIsNone( + resp_dict.get("data"), + msg="Error in data information return") + + # All incoming withsubpack=0 + resp = self.client.post("/dependInfo/beDepend", + data=json.dumps({ + "packagename": "A", + "dbname": f"{self.db_name}", + "withsubpack": "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.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 code return") + + self.assertIn("data", resp_dict, msg="Error in data format return") + self.assertIsNotNone( + resp_dict.get("data"), + msg="Error in data information return") + + # All incoming withsubpack=1 + resp = self.client.post("/dependInfo/beDepend", + data=json.dumps({ + "packagename": "A", + "dbname": f"{self.db_name}", + "withsubpack": "1" + }), + 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 code 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_parameter(self): + """ + Parameter error + """ + + # packagename Parameter error + resp = self.client.post("/dependInfo/beDepend", + data=json.dumps({ + "packagename": "詹姆斯", + "dbname": f"{self.db_name}", + "withsubpack": "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.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 code return") + + self.assertIn("data", resp_dict, msg="Error in data format return") + self.assertIsNone( + resp_dict.get("data"), + msg="Error in data information return") + + # dbname Parameter error + resp = self.client.post("/dependInfo/beDepend", + data=json.dumps({ + "packagename": "ATpy", + "dbname": "asdfgjhk", + "withsubpack": "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.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 code return") + + self.assertIn("data", resp_dict, msg="Error in data format return") + self.assertIsNone( + resp_dict.get("data"), + msg="Error in data information return") + + # withsubpack Parameter error + resp = self.client.post("/dependInfo/beDepend", + data=json.dumps({ + "packagename": "CUnit", + "dbname": f"{self.db_name}", + "withsubpack": "3" + }), + 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 code 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): + """ + Results contrast + """ + correct_list = get_correct_json_by_filename("dependinfo_be_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("/dependInfo/beDepend", + 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_self_depend.py b/packageship/test/test_module/dependinfo_tests/test_dependinfo_self_depend.py new file mode 100644 index 0000000000000000000000000000000000000000..650a81d90996af10a70e9b23bb589cfdb94d850c --- /dev/null +++ b/packageship/test/test_module/dependinfo_tests/test_dependinfo_self_depend.py @@ -0,0 +1,289 @@ +#!/usr/bin/python3 +# -*- coding:utf-8 -*- +""" +TestSelfDepend +""" +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 +from packageship.application.apps.package.function.searchdb import db_priority + + +class TestDependInfoSelfDepend(ReadTestBase): + """ + TestSelfDepend + """ + + def test_empty_parameter(self): + """ + test_empty_parameter + Returns: + + """ + resp = self.client.post("/dependInfo/selfDepend", + data='{}', + content_type="application/json") + + resp_dict = json.loads(resp.data) + + self.assertIn("code", resp_dict, msg="Wrong return format!") + self.assertEqual(ResponseCode.PARAM_ERROR, + resp_dict.get("code"), + msg="Error in status code return!") + self.assertIn("msg", resp_dict, msg="Wrong return format!") + self.assertEqual(ResponseCode.CODE_MSG_MAP.get(ResponseCode.PARAM_ERROR), + resp_dict.get("msg"), + msg="Error in status information return!") + + self.assertIn("data", resp_dict, msg="Wrong return format!") + self.assertIsNone(resp_dict.get("data"), msg="Data return error!") + + resp = self.client.post("/dependInfo/selfDepend", + data=json.dumps({ + "packagename": "A1", + }), + content_type="application/json") + + resp_dict = json.loads(resp.data) + + self.assertIn("code", resp_dict, msg="Wrong return format!") + self.assertEqual(ResponseCode.SUCCESS, + resp_dict.get("code"), + msg="Error in status code return!") + self.assertIn("msg", resp_dict, msg="Wrong return format!") + self.assertEqual(ResponseCode.CODE_MSG_MAP.get(ResponseCode.SUCCESS), + resp_dict.get("msg"), + msg="Error in status information return!") + + self.assertIn("data", resp_dict, msg="Wrong return format!") + self.assertIsNotNone(resp_dict.get("data"), msg="Data return error!") + + resp = self.client.post("/dependInfo/selfDepend", + data=json.dumps({ + "packagename": "A1", + "db_list": db_priority() + }), + content_type="application/json") + + resp_dict = json.loads(resp.data) + + self.assertIn("code", resp_dict, msg="Wrong return format!") + self.assertEqual(ResponseCode.SUCCESS, + resp_dict.get("code"), + msg="Error in status code return!") + self.assertIn("msg", resp_dict, msg="Wrong return format!") + self.assertEqual(ResponseCode.CODE_MSG_MAP.get(ResponseCode.SUCCESS), + resp_dict.get("msg"), + msg="Error in status information return!") + + self.assertIn("data", resp_dict, msg="Wrong return format!") + self.assertIsNotNone(resp_dict.get("data"), msg="Data return error!") + + resp = self.client.post("/dependInfo/selfDepend", + data=json.dumps({ + "packagename": "A1", + "db_list": db_priority(), + "selfbuild": "0" + }), + content_type="application/json") + + resp_dict = json.loads(resp.data) + + self.assertIn("code", resp_dict, msg="Wrong return format!") + self.assertEqual(ResponseCode.SUCCESS, + resp_dict.get("code"), + msg="Error in status code return!") + self.assertIn("msg", resp_dict, msg="Wrong return format!") + self.assertEqual(ResponseCode.CODE_MSG_MAP.get(ResponseCode.SUCCESS), + resp_dict.get("msg"), + msg="Error in status information return!") + + self.assertIn("data", resp_dict, msg="Wrong return format!") + self.assertIsNotNone(resp_dict.get("data"), msg="Data return error!") + + resp = self.client.post("/dependInfo/selfDepend", + data=json.dumps({ + "packagename": "A1", + "db_list": db_priority(), + "selfbuild": "0", + "withsubpack": "0" + }), + content_type="application/json") + + resp_dict = json.loads(resp.data) + + self.assertIn("code", resp_dict, msg="Wrong return format!") + self.assertEqual(ResponseCode.SUCCESS, + resp_dict.get("code"), + msg="Error in status code return!") + self.assertIn("msg", resp_dict, msg="Wrong return format!") + self.assertEqual(ResponseCode.CODE_MSG_MAP.get(ResponseCode.SUCCESS), + resp_dict.get("msg"), + msg="Error in status information return!") + + self.assertIn("data", resp_dict, msg="Wrong return format!") + self.assertIsNotNone(resp_dict.get("data"), msg="Data return error!") + + def test_wrong_parameter(self): + """ + test_wrong_parameter + Returns: + + """ + resp = self.client.post("/dependInfo/selfDepend", + data=json.dumps({ + "packagename": "wukong" + }), + content_type="application/json") + + resp_dict = json.loads(resp.data) + + self.assertIn("code", resp_dict, msg="Wrong return format!") + self.assertEqual(ResponseCode.PACK_NAME_NOT_FOUND, + resp_dict.get("code"), + msg="Error in status code return!") + self.assertIn("msg", resp_dict, msg="Wrong return format!") + self.assertEqual(ResponseCode.CODE_MSG_MAP.get(ResponseCode.PACK_NAME_NOT_FOUND), + resp_dict.get("msg"), + msg="Error in status information return!") + + self.assertIn("data", resp_dict, msg="Wrong return format!") + self.assertIsNone(resp_dict.get("data"), msg="Data return error!") + + resp = self.client.post("/dependInfo/selfDepend", + data=json.dumps({ + "packagename": "A1", + "db_list": [1, 2, 3, 4] + }), + content_type="application/json") + + resp_dict = json.loads(resp.data) + + self.assertIn("code", resp_dict, msg="Wrong return format!") + self.assertEqual(ResponseCode.PARAM_ERROR, + resp_dict.get("code"), + msg="Error in status code return!") + self.assertIn("msg", resp_dict, msg="Wrong return format!") + self.assertEqual(ResponseCode.CODE_MSG_MAP.get(ResponseCode.PARAM_ERROR), + resp_dict.get("msg"), + msg="Error in status information return!") + + self.assertIn("data", resp_dict, msg="Wrong return format!") + self.assertIsNone(resp_dict.get("data"), msg="Data return error!") + + resp = self.client.post("/dependInfo/selfDepend", + data=json.dumps({ + "packagename": "A1", + "db_list": ["bajie", "shifu"] + }), + content_type="application/json") + + resp_dict = json.loads(resp.data) + + self.assertIn("code", resp_dict, msg="Wrong return format!") + self.assertEqual(ResponseCode.DB_NAME_ERROR, + resp_dict.get("code"), + msg="Error in status code return!") + self.assertIn("msg", resp_dict, msg="Wrong return format!") + self.assertEqual(ResponseCode.CODE_MSG_MAP.get(ResponseCode.DB_NAME_ERROR), + resp_dict.get("msg"), + msg="Error in status information return!") + + self.assertIn("data", resp_dict, msg="Wrong return format!") + self.assertIsNone(resp_dict.get("data"), msg="Data return error!") + + resp = self.client.post("/dependInfo/selfDepend", + data=json.dumps({ + "packagename": "A1", + "db_list": db_priority(), + "selfbuild": "nverguo" + }), + content_type="application/json") + + resp_dict = json.loads(resp.data) + + self.assertIn("code", resp_dict, msg="Wrong return format!") + self.assertEqual(ResponseCode.PARAM_ERROR, + resp_dict.get("code"), + msg="Error in status code return!") + self.assertIn("msg", resp_dict, msg="Wrong return format!") + self.assertEqual(ResponseCode.CODE_MSG_MAP.get(ResponseCode.PARAM_ERROR), + resp_dict.get("msg"), + msg="Error in status information return!") + + self.assertIn("data", resp_dict, msg="Wrong return format!") + self.assertIsNone(resp_dict.get("data"), msg="Data return error!") + + resp = self.client.post("/dependInfo/selfDepend", + data=json.dumps({ + "packagename": "A1", + "db_list": db_priority(), + "selfbuild": "0", + "withsubpack": "pansidong", + }), + content_type="application/json") + + resp_dict = json.loads(resp.data) + + self.assertIn("code", resp_dict, msg="Wrong return format!") + self.assertEqual(ResponseCode.PARAM_ERROR, + resp_dict.get("code"), + msg="Error in status code return!") + self.assertIn("msg", resp_dict, msg="Wrong return format!") + self.assertEqual(ResponseCode.CODE_MSG_MAP.get(ResponseCode.PARAM_ERROR), + resp_dict.get("msg"), + msg="Error in status information return!") + + self.assertIn("data", resp_dict, msg="Wrong return format!") + self.assertIsNone(resp_dict.get("data"), msg="Data return error!") + + resp = self.client.post("/dependInfo/selfDepend", + data=json.dumps({ + "packagename": "A1", + "db_list": db_priority(), + "selfbuild": "0", + "withsubpack": "0", + "packtype": "pansidaxian" + }), + content_type="application/json") + + resp_dict = json.loads(resp.data) + + self.assertIn("code", resp_dict, msg="Wrong return format!") + self.assertEqual(ResponseCode.PARAM_ERROR, + resp_dict.get("code"), + msg="Error in status code return!") + self.assertIn("msg", resp_dict, msg="Wrong return format!") + self.assertEqual(ResponseCode.CODE_MSG_MAP.get(ResponseCode.PARAM_ERROR), + resp_dict.get("msg"), + msg="Error in status information return!") + + self.assertIn("data", resp_dict, msg="Wrong return format!") + self.assertIsNone(resp_dict.get("data"), msg="Data return error!") + + def test_true_params_result(self): + """ + test_true_params_result + Returns: + + """ + correct_list = get_correct_json_by_filename("dependinfo_self_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("/dependInfo/selfDepend", + 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()