From: sousaedu Date: Wed, 24 Nov 2021 02:16:11 +0000 (+0000) Subject: Extracting Ns._process_flavor_params() and creating unit test X-Git-Tag: v12.0.0rc1~47 X-Git-Url: https://osm.etsi.org/gitweb/?a=commitdiff_plain;h=refs%2Fchanges%2F04%2F11404%2F11;p=osm%2FRO.git Extracting Ns._process_flavor_params() and creating unit test Change-Id: I7146a1a7a2fa703443bf218be351e39f6d98d699 Signed-off-by: sousaedu --- diff --git a/NG-RO/osm_ng_ro/ns.py b/NG-RO/osm_ng_ro/ns.py index f57e7bb1..a7d8aa61 100644 --- a/NG-RO/osm_ng_ro/ns.py +++ b/NG-RO/osm_ng_ro/ns.py @@ -18,7 +18,7 @@ # import yaml import logging -from typing import Any, Dict +from typing import Any, Dict, Tuple from traceback import format_exc as traceback_format_exc from osm_ng_ro.ns_thread import NsWorker, NsWorkerException, deep_get from osm_ng_ro.validation import validate_input, deploy_schema @@ -471,6 +471,7 @@ class Ns(object): @staticmethod def _process_image_params( target_image: Dict[str, Any], + indata: Dict[str, Any], vim_info: Dict[str, Any], target_record_id: str, ) -> Dict[str, Any]: @@ -478,6 +479,7 @@ class Ns(object): Args: target_image (Dict[str, Any]): [description] + indata (Dict[str, Any]): [description] vim_info (Dict[str, Any]): [description] target_record_id (str): [description] @@ -525,6 +527,234 @@ class Ns(object): return quota + @staticmethod + def _process_guest_epa_quota_params( + guest_epa_quota: Dict[str, Any], + epa_vcpu_set: bool, + ) -> Dict[str, Any]: + """Function to extract the guest epa quota parameters. + + Args: + guest_epa_quota (Dict[str, Any]): [description] + epa_vcpu_set (bool): [description] + + Returns: + Dict[str, Any]: [description] + """ + result = {} + + if guest_epa_quota.get("cpu-quota") and not epa_vcpu_set: + cpuquota = Ns._get_resource_allocation_params( + guest_epa_quota.get("cpu-quota") + ) + + if cpuquota: + result["cpu-quota"] = cpuquota + + if guest_epa_quota.get("mem-quota"): + vduquota = Ns._get_resource_allocation_params( + guest_epa_quota.get("mem-quota") + ) + + if vduquota: + result["mem-quota"] = vduquota + + if guest_epa_quota.get("disk-io-quota"): + diskioquota = Ns._get_resource_allocation_params( + guest_epa_quota.get("disk-io-quota") + ) + + if diskioquota: + result["disk-io-quota"] = diskioquota + + if guest_epa_quota.get("vif-quota"): + vifquota = Ns._get_resource_allocation_params( + guest_epa_quota.get("vif-quota") + ) + + if vifquota: + result["vif-quota"] = vifquota + + return result + + @staticmethod + def _process_guest_epa_numa_params( + guest_epa_quota: Dict[str, Any], + ) -> Tuple[Dict[str, Any], bool]: + """[summary] + + Args: + guest_epa_quota (Dict[str, Any]): [description] + + Returns: + Tuple[Dict[str, Any], bool]: [description] + """ + numa = {} + epa_vcpu_set = False + + if guest_epa_quota.get("numa-node-policy"): + numa_node_policy = guest_epa_quota.get("numa-node-policy") + + if numa_node_policy.get("node"): + numa_node = numa_node_policy["node"][0] + + if numa_node.get("num-cores"): + numa["cores"] = numa_node["num-cores"] + epa_vcpu_set = True + + paired_threads = numa_node.get("paired-threads", {}) + if paired_threads.get("num-paired-threads"): + numa["paired-threads"] = int( + numa_node["paired-threads"]["num-paired-threads"] + ) + epa_vcpu_set = True + + if paired_threads.get("paired-thread-ids"): + numa["paired-threads-id"] = [] + + for pair in paired_threads["paired-thread-ids"]: + numa["paired-threads-id"].append( + ( + str(pair["thread-a"]), + str(pair["thread-b"]), + ) + ) + + if numa_node.get("num-threads"): + numa["threads"] = int(numa_node["num-threads"]) + epa_vcpu_set = True + + if numa_node.get("memory-mb"): + numa["memory"] = max(int(int(numa_node["memory-mb"]) / 1024), 1) + + return numa, epa_vcpu_set + + @staticmethod + def _process_guest_epa_cpu_pinning_params( + guest_epa_quota: Dict[str, Any], + vcpu_count: int, + epa_vcpu_set: bool, + ) -> Tuple[Dict[str, Any], bool]: + """[summary] + + Args: + guest_epa_quota (Dict[str, Any]): [description] + vcpu_count (int): [description] + epa_vcpu_set (bool): [description] + + Returns: + Tuple[Dict[str, Any], bool]: [description] + """ + numa = {} + local_epa_vcpu_set = epa_vcpu_set + + if ( + guest_epa_quota.get("cpu-pinning-policy") == "DEDICATED" + and not epa_vcpu_set + ): + numa[ + "cores" + if guest_epa_quota.get("cpu-thread-pinning-policy") != "PREFER" + else "threads" + ] = max(vcpu_count, 1) + local_epa_vcpu_set = True + + return numa, local_epa_vcpu_set + + @staticmethod + def _process_epa_params( + target_flavor: Dict[str, Any], + ) -> Dict[str, Any]: + """[summary] + + Args: + target_flavor (Dict[str, Any]): [description] + + Returns: + Dict[str, Any]: [description] + """ + extended = {} + numa = {} + + if target_flavor.get("guest-epa"): + guest_epa = target_flavor["guest-epa"] + + numa, epa_vcpu_set = Ns._process_guest_epa_numa_params( + guest_epa_quota=guest_epa + ) + + if guest_epa.get("mempage-size"): + extended["mempage-size"] = guest_epa.get("mempage-size") + + tmp_numa, epa_vcpu_set = Ns._process_guest_epa_cpu_pinning_params( + guest_epa_quota=guest_epa, + vcpu_count=int(target_flavor.get("vcpu-count", 1)), + epa_vcpu_set=epa_vcpu_set, + ) + numa.update(tmp_numa) + + extended.update( + Ns._process_guest_epa_quota_params( + guest_epa_quota=guest_epa, + epa_vcpu_set=epa_vcpu_set, + ) + ) + + if numa: + extended["numas"] = [numa] + + return extended + + @staticmethod + def _process_flavor_params( + target_flavor: Dict[str, Any], + indata: Dict[str, Any], + vim_info: Dict[str, Any], + target_record_id: str, + ) -> Dict[str, Any]: + """[summary] + + Args: + target_flavor (Dict[str, Any]): [description] + indata (Dict[str, Any]): [description] + vim_info (Dict[str, Any]): [description] + target_record_id (str): [description] + + Returns: + Dict[str, Any]: [description] + """ + flavor_data = { + "disk": int(target_flavor["storage-gb"]), + "ram": int(target_flavor["memory-mb"]), + "vcpus": int(target_flavor["vcpu-count"]), + } + + target_vdur = {} + for vnf in indata.get("vnf", []): + for vdur in vnf.get("vdur", []): + if vdur.get("ns-flavor-id") == target_flavor["id"]: + target_vdur = vdur + + for storage in target_vdur.get("virtual-storages", []): + if ( + storage.get("type-of-storage") + == "etsi-nfv-descriptors:ephemeral-storage" + ): + flavor_data["ephemeral"] = int(storage.get("size-of-storage", 0)) + elif storage.get("type-of-storage") == "etsi-nfv-descriptors:swap-storage": + flavor_data["swap"] = int(storage.get("size-of-storage", 0)) + + extended = Ns._process_epa_params(target_flavor) + if extended: + flavor_data["extended"] = extended + + extra_dict = {"find_params": {"flavor_data": flavor_data}} + flavor_data_name = flavor_data.copy() + flavor_data_name["name"] = target_flavor["name"] + extra_dict["params"] = {"flavor_data": flavor_data_name} + + return extra_dict + def deploy(self, session, indata, version, nsr_id, *args, **kwargs): self.logger.debug("ns.deploy nsr_id={} indata={}".format(nsr_id, indata)) validate_input(indata, deploy_schema) @@ -581,161 +811,6 @@ class Ns(object): index += 1 - def _process_flavor_params(target_flavor, vim_info, target_record_id): - nonlocal indata - - flavor_data = { - "disk": int(target_flavor["storage-gb"]), - "ram": int(target_flavor["memory-mb"]), - "vcpus": int(target_flavor["vcpu-count"]), - } - numa = {} - extended = {} - - target_vdur = None - for vnf in indata.get("vnf", []): - for vdur in vnf.get("vdur", []): - if vdur.get("ns-flavor-id") == target_flavor["id"]: - target_vdur = vdur - - for storage in target_vdur.get("virtual-storages", []): - if ( - storage.get("type-of-storage") - == "etsi-nfv-descriptors:ephemeral-storage" - ): - flavor_data["ephemeral"] = int( - storage.get("size-of-storage", 0) - ) - elif ( - storage.get("type-of-storage") - == "etsi-nfv-descriptors:swap-storage" - ): - flavor_data["swap"] = int(storage.get("size-of-storage", 0)) - - if target_flavor.get("guest-epa"): - extended = {} - epa_vcpu_set = False - - if target_flavor["guest-epa"].get("numa-node-policy"): - numa_node_policy = target_flavor["guest-epa"].get( - "numa-node-policy" - ) - - if numa_node_policy.get("node"): - numa_node = numa_node_policy["node"][0] - - if numa_node.get("num-cores"): - numa["cores"] = numa_node["num-cores"] - epa_vcpu_set = True - - if numa_node.get("paired-threads"): - if numa_node["paired-threads"].get( - "num-paired-threads" - ): - numa["paired-threads"] = int( - numa_node["paired-threads"][ - "num-paired-threads" - ] - ) - epa_vcpu_set = True - - if len( - numa_node["paired-threads"].get("paired-thread-ids") - ): - numa["paired-threads-id"] = [] - - for pair in numa_node["paired-threads"][ - "paired-thread-ids" - ]: - numa["paired-threads-id"].append( - ( - str(pair["thread-a"]), - str(pair["thread-b"]), - ) - ) - - if numa_node.get("num-threads"): - numa["threads"] = int(numa_node["num-threads"]) - epa_vcpu_set = True - - if numa_node.get("memory-mb"): - numa["memory"] = max( - int(numa_node["memory-mb"] / 1024), 1 - ) - - if target_flavor["guest-epa"].get("mempage-size"): - extended["mempage-size"] = target_flavor["guest-epa"].get( - "mempage-size" - ) - - if ( - target_flavor["guest-epa"].get("cpu-pinning-policy") - and not epa_vcpu_set - ): - if ( - target_flavor["guest-epa"]["cpu-pinning-policy"] - == "DEDICATED" - ): - if ( - target_flavor["guest-epa"].get( - "cpu-thread-pinning-policy" - ) - and target_flavor["guest-epa"][ - "cpu-thread-pinning-policy" - ] - != "PREFER" - ): - numa["cores"] = max(flavor_data["vcpus"], 1) - else: - numa["threads"] = max(flavor_data["vcpus"], 1) - - epa_vcpu_set = True - - if target_flavor["guest-epa"].get("cpu-quota") and not epa_vcpu_set: - cpuquota = Ns._get_resource_allocation_params( - target_flavor["guest-epa"].get("cpu-quota") - ) - - if cpuquota: - extended["cpu-quota"] = cpuquota - - if target_flavor["guest-epa"].get("mem-quota"): - vduquota = Ns._get_resource_allocation_params( - target_flavor["guest-epa"].get("mem-quota") - ) - - if vduquota: - extended["mem-quota"] = vduquota - - if target_flavor["guest-epa"].get("disk-io-quota"): - diskioquota = Ns._get_resource_allocation_params( - target_flavor["guest-epa"].get("disk-io-quota") - ) - - if diskioquota: - extended["disk-io-quota"] = diskioquota - - if target_flavor["guest-epa"].get("vif-quota"): - vifquota = Ns._get_resource_allocation_params( - target_flavor["guest-epa"].get("vif-quota") - ) - - if vifquota: - extended["vif-quota"] = vifquota - - if numa: - extended["numas"] = [numa] - - if extended: - flavor_data["extended"] = extended - - extra_dict = {"find_params": {"flavor_data": flavor_data}} - flavor_data_name = flavor_data.copy() - flavor_data_name["name"] = target_flavor["name"] - extra_dict["params"] = {"flavor_data": flavor_data_name} - - return extra_dict - def _ip_profile_2_ro(ip_profile): if not ip_profile: return None @@ -765,8 +840,7 @@ class Ns(object): return ro_ip_profile - def _process_net_params(target_vld, vim_info, target_record_id): - nonlocal indata + def _process_net_params(target_vld, indata, vim_info, target_record_id): extra_dict = {} if vim_info.get("sdn"): @@ -818,10 +892,9 @@ class Ns(object): return extra_dict - def _process_vdu_params(target_vdu, vim_info, target_record_id): + def _process_vdu_params(target_vdu, indata, vim_info, target_record_id): nonlocal vnfr_id nonlocal nsr_id - nonlocal indata nonlocal vnfr nonlocal vdu2cloud_init nonlocal tasks_by_target_record_id @@ -985,6 +1058,7 @@ class Ns(object): nonlocal action_id nonlocal nsr_id nonlocal task_index + nonlocal indata # ensure all the target_list elements has an "id". If not assign the index as id for target_index, tl in enumerate(target_list): @@ -1082,7 +1156,7 @@ class Ns(object): target_record_id += ".sdn" extra_dict = process_params( - target_item, target_viminfo, target_record_id + target_item, indata, target_viminfo, target_record_id ) self._assign_vim(target_vim) @@ -1228,7 +1302,7 @@ class Ns(object): db_update=db_nsr_update, db_path="flavor", item="flavor", - process_params=_process_flavor_params, + process_params=Ns._process_flavor_params, ) # VNF.vld diff --git a/NG-RO/osm_ng_ro/tests/test_ns.py b/NG-RO/osm_ng_ro/tests/test_ns.py index 4cfc30bc..6980b88c 100644 --- a/NG-RO/osm_ng_ro/tests/test_ns.py +++ b/NG-RO/osm_ng_ro/tests/test_ns.py @@ -152,6 +152,7 @@ class TestNs(unittest.TestCase): result = Ns._process_image_params( target_image=target_image, + indata=None, vim_info=None, target_record_id=None, ) @@ -168,6 +169,7 @@ class TestNs(unittest.TestCase): result = Ns._process_image_params( target_image=target_image, + indata=None, vim_info=None, target_record_id=None, ) @@ -188,6 +190,7 @@ class TestNs(unittest.TestCase): result = Ns._process_image_params( target_image=target_image, + indata=None, vim_info=None, target_record_id=None, ) @@ -208,6 +211,7 @@ class TestNs(unittest.TestCase): result = Ns._process_image_params( target_image=target_image, + indata=None, vim_info=None, target_record_id=None, ) @@ -228,6 +232,7 @@ class TestNs(unittest.TestCase): result = Ns._process_image_params( target_image=target_image, + indata=None, vim_info=None, target_record_id=None, ) @@ -315,3 +320,1471 @@ class TestNs(unittest.TestCase): ) self.assertDictEqual(expected_result, result) + + @patch("osm_ng_ro.ns.Ns._get_resource_allocation_params") + def test__process_guest_epa_quota_params_with_empty_quota_epa_cpu( + self, + resource_allocation, + ): + expected_result = {} + guest_epa_quota = {} + epa_vcpu_set = True + + result = Ns._process_guest_epa_quota_params( + guest_epa_quota=guest_epa_quota, + epa_vcpu_set=epa_vcpu_set, + ) + + self.assertDictEqual(expected_result, result) + self.assertFalse(resource_allocation.called) + + @patch("osm_ng_ro.ns.Ns._get_resource_allocation_params") + def test__process_guest_epa_quota_params_with_empty_quota_false_epa_cpu( + self, + resource_allocation, + ): + expected_result = {} + guest_epa_quota = {} + epa_vcpu_set = False + + result = Ns._process_guest_epa_quota_params( + guest_epa_quota=guest_epa_quota, + epa_vcpu_set=epa_vcpu_set, + ) + + self.assertDictEqual(expected_result, result) + self.assertFalse(resource_allocation.called) + + @patch("osm_ng_ro.ns.Ns._get_resource_allocation_params") + def test__process_guest_epa_quota_params_with_wrong_quota_epa_cpu( + self, + resource_allocation, + ): + expected_result = {} + guest_epa_quota = { + "no-quota": "nothing", + } + epa_vcpu_set = True + + result = Ns._process_guest_epa_quota_params( + guest_epa_quota=guest_epa_quota, + epa_vcpu_set=epa_vcpu_set, + ) + + self.assertDictEqual(expected_result, result) + self.assertFalse(resource_allocation.called) + + @patch("osm_ng_ro.ns.Ns._get_resource_allocation_params") + def test__process_guest_epa_quota_params_with_wrong_quota_false_epa_cpu( + self, + resource_allocation, + ): + expected_result = {} + guest_epa_quota = { + "no-quota": "nothing", + } + epa_vcpu_set = False + + result = Ns._process_guest_epa_quota_params( + guest_epa_quota=guest_epa_quota, + epa_vcpu_set=epa_vcpu_set, + ) + + self.assertDictEqual(expected_result, result) + self.assertFalse(resource_allocation.called) + + @patch("osm_ng_ro.ns.Ns._get_resource_allocation_params") + def test__process_guest_epa_quota_params_with_cpu_quota_epa_cpu( + self, + resource_allocation, + ): + expected_result = {} + guest_epa_quota = { + "cpu-quota": { + "limit": "10", + "reserve": "20", + "shares": "30", + }, + } + epa_vcpu_set = True + + result = Ns._process_guest_epa_quota_params( + guest_epa_quota=guest_epa_quota, + epa_vcpu_set=epa_vcpu_set, + ) + + self.assertDictEqual(expected_result, result) + self.assertFalse(resource_allocation.called) + + @patch("osm_ng_ro.ns.Ns._get_resource_allocation_params") + def test__process_guest_epa_quota_params_with_cpu_quota_false_epa_cpu( + self, + resource_allocation, + ): + expected_result = { + "cpu-quota": { + "limit": 10, + "reserve": 20, + "shares": 30, + }, + } + guest_epa_quota = { + "cpu-quota": { + "limit": "10", + "reserve": "20", + "shares": "30", + }, + } + epa_vcpu_set = False + + resource_allocation_param = { + "limit": "10", + "reserve": "20", + "shares": "30", + } + resource_allocation.return_value = { + "limit": 10, + "reserve": 20, + "shares": 30, + } + + result = Ns._process_guest_epa_quota_params( + guest_epa_quota=guest_epa_quota, + epa_vcpu_set=epa_vcpu_set, + ) + + resource_allocation.assert_called_once_with(resource_allocation_param) + self.assertDictEqual(expected_result, result) + + @patch("osm_ng_ro.ns.Ns._get_resource_allocation_params") + def test__process_guest_epa_quota_params_with_mem_quota_epa_cpu( + self, + resource_allocation, + ): + expected_result = { + "mem-quota": { + "limit": 10, + "reserve": 20, + "shares": 30, + }, + } + guest_epa_quota = { + "mem-quota": { + "limit": "10", + "reserve": "20", + "shares": "30", + }, + } + epa_vcpu_set = True + + resource_allocation_param = { + "limit": "10", + "reserve": "20", + "shares": "30", + } + resource_allocation.return_value = { + "limit": 10, + "reserve": 20, + "shares": 30, + } + + result = Ns._process_guest_epa_quota_params( + guest_epa_quota=guest_epa_quota, + epa_vcpu_set=epa_vcpu_set, + ) + + resource_allocation.assert_called_once_with(resource_allocation_param) + self.assertDictEqual(expected_result, result) + + @patch("osm_ng_ro.ns.Ns._get_resource_allocation_params") + def test__process_guest_epa_quota_params_with_mem_quota_false_epa_cpu( + self, + resource_allocation, + ): + expected_result = { + "mem-quota": { + "limit": 10, + "reserve": 20, + "shares": 30, + }, + } + guest_epa_quota = { + "mem-quota": { + "limit": "10", + "reserve": "20", + "shares": "30", + }, + } + epa_vcpu_set = False + + resource_allocation_param = { + "limit": "10", + "reserve": "20", + "shares": "30", + } + resource_allocation.return_value = { + "limit": 10, + "reserve": 20, + "shares": 30, + } + + result = Ns._process_guest_epa_quota_params( + guest_epa_quota=guest_epa_quota, + epa_vcpu_set=epa_vcpu_set, + ) + + resource_allocation.assert_called_once_with(resource_allocation_param) + self.assertDictEqual(expected_result, result) + + @patch("osm_ng_ro.ns.Ns._get_resource_allocation_params") + def test__process_guest_epa_quota_params_with_disk_io_quota_epa_cpu( + self, + resource_allocation, + ): + expected_result = { + "disk-io-quota": { + "limit": 10, + "reserve": 20, + "shares": 30, + }, + } + guest_epa_quota = { + "disk-io-quota": { + "limit": "10", + "reserve": "20", + "shares": "30", + }, + } + epa_vcpu_set = True + + resource_allocation_param = { + "limit": "10", + "reserve": "20", + "shares": "30", + } + resource_allocation.return_value = { + "limit": 10, + "reserve": 20, + "shares": 30, + } + + result = Ns._process_guest_epa_quota_params( + guest_epa_quota=guest_epa_quota, + epa_vcpu_set=epa_vcpu_set, + ) + + resource_allocation.assert_called_once_with(resource_allocation_param) + self.assertDictEqual(expected_result, result) + + @patch("osm_ng_ro.ns.Ns._get_resource_allocation_params") + def test__process_guest_epa_quota_params_with_disk_io_quota_false_epa_cpu( + self, + resource_allocation, + ): + expected_result = { + "disk-io-quota": { + "limit": 10, + "reserve": 20, + "shares": 30, + }, + } + guest_epa_quota = { + "disk-io-quota": { + "limit": "10", + "reserve": "20", + "shares": "30", + }, + } + epa_vcpu_set = False + + resource_allocation_param = { + "limit": "10", + "reserve": "20", + "shares": "30", + } + resource_allocation.return_value = { + "limit": 10, + "reserve": 20, + "shares": 30, + } + + result = Ns._process_guest_epa_quota_params( + guest_epa_quota=guest_epa_quota, + epa_vcpu_set=epa_vcpu_set, + ) + + resource_allocation.assert_called_once_with(resource_allocation_param) + self.assertDictEqual(expected_result, result) + + @patch("osm_ng_ro.ns.Ns._get_resource_allocation_params") + def test__process_guest_epa_quota_params_with_vif_quota_epa_cpu( + self, + resource_allocation, + ): + expected_result = { + "vif-quota": { + "limit": 10, + "reserve": 20, + "shares": 30, + }, + } + guest_epa_quota = { + "vif-quota": { + "limit": "10", + "reserve": "20", + "shares": "30", + }, + } + epa_vcpu_set = True + + resource_allocation_param = { + "limit": "10", + "reserve": "20", + "shares": "30", + } + resource_allocation.return_value = { + "limit": 10, + "reserve": 20, + "shares": 30, + } + + result = Ns._process_guest_epa_quota_params( + guest_epa_quota=guest_epa_quota, + epa_vcpu_set=epa_vcpu_set, + ) + + resource_allocation.assert_called_once_with(resource_allocation_param) + self.assertDictEqual(expected_result, result) + + @patch("osm_ng_ro.ns.Ns._get_resource_allocation_params") + def test__process_guest_epa_quota_params_with_vif_quota_false_epa_cpu( + self, + resource_allocation, + ): + expected_result = { + "vif-quota": { + "limit": 10, + "reserve": 20, + "shares": 30, + }, + } + guest_epa_quota = { + "vif-quota": { + "limit": "10", + "reserve": "20", + "shares": "30", + }, + } + epa_vcpu_set = False + + resource_allocation_param = { + "limit": "10", + "reserve": "20", + "shares": "30", + } + resource_allocation.return_value = { + "limit": 10, + "reserve": 20, + "shares": 30, + } + + result = Ns._process_guest_epa_quota_params( + guest_epa_quota=guest_epa_quota, + epa_vcpu_set=epa_vcpu_set, + ) + + resource_allocation.assert_called_once_with(resource_allocation_param) + self.assertDictEqual(expected_result, result) + + @patch("osm_ng_ro.ns.Ns._get_resource_allocation_params") + def test__process_guest_epa_quota_params_with_quota_epa_cpu( + self, + resource_allocation, + ): + expected_result = { + "mem-quota": { + "limit": 10, + "reserve": 20, + "shares": 30, + }, + "disk-io-quota": { + "limit": 10, + "reserve": 20, + "shares": 30, + }, + "vif-quota": { + "limit": 10, + "reserve": 20, + "shares": 30, + }, + } + guest_epa_quota = { + "cpu-quota": { + "limit": "10", + "reserve": "20", + "shares": "30", + }, + "mem-quota": { + "limit": "10", + "reserve": "20", + "shares": "30", + }, + "disk-io-quota": { + "limit": "10", + "reserve": "20", + "shares": "30", + }, + "vif-quota": { + "limit": "10", + "reserve": "20", + "shares": "30", + }, + } + epa_vcpu_set = True + + resource_allocation.return_value = { + "limit": 10, + "reserve": 20, + "shares": 30, + } + + result = Ns._process_guest_epa_quota_params( + guest_epa_quota=guest_epa_quota, + epa_vcpu_set=epa_vcpu_set, + ) + + self.assertTrue(resource_allocation.called) + self.assertDictEqual(expected_result, result) + + @patch("osm_ng_ro.ns.Ns._get_resource_allocation_params") + def test__process_guest_epa_quota_params_with_quota_epa_cpu_no_set( + self, + resource_allocation, + ): + expected_result = { + "cpu-quota": { + "limit": 10, + "reserve": 20, + "shares": 30, + }, + "mem-quota": { + "limit": 10, + "reserve": 20, + "shares": 30, + }, + "disk-io-quota": { + "limit": 10, + "reserve": 20, + "shares": 30, + }, + "vif-quota": { + "limit": 10, + "reserve": 20, + "shares": 30, + }, + } + guest_epa_quota = { + "cpu-quota": { + "limit": "10", + "reserve": "20", + "shares": "30", + }, + "mem-quota": { + "limit": "10", + "reserve": "20", + "shares": "30", + }, + "disk-io-quota": { + "limit": "10", + "reserve": "20", + "shares": "30", + }, + "vif-quota": { + "limit": "10", + "reserve": "20", + "shares": "30", + }, + } + epa_vcpu_set = False + + resource_allocation.return_value = { + "limit": 10, + "reserve": 20, + "shares": 30, + } + + result = Ns._process_guest_epa_quota_params( + guest_epa_quota=guest_epa_quota, + epa_vcpu_set=epa_vcpu_set, + ) + + self.assertTrue(resource_allocation.called) + self.assertDictEqual(expected_result, result) + + def test__process_guest_epa_numa_params_with_empty_numa_params(self): + expected_numa_result = {} + expected_epa_vcpu_set_result = False + guest_epa_quota = {} + + numa_result, epa_vcpu_set_result = Ns._process_guest_epa_numa_params( + guest_epa_quota=guest_epa_quota, + ) + + self.assertDictEqual(expected_numa_result, numa_result) + self.assertEqual(expected_epa_vcpu_set_result, epa_vcpu_set_result) + + def test__process_guest_epa_numa_params_with_wrong_numa_params(self): + expected_numa_result = {} + expected_epa_vcpu_set_result = False + guest_epa_quota = {"no_nume": "here"} + + numa_result, epa_vcpu_set_result = Ns._process_guest_epa_numa_params( + guest_epa_quota=guest_epa_quota, + ) + + self.assertDictEqual(expected_numa_result, numa_result) + self.assertEqual(expected_epa_vcpu_set_result, epa_vcpu_set_result) + + def test__process_guest_epa_numa_params_with_numa_node_policy(self): + expected_numa_result = {} + expected_epa_vcpu_set_result = False + guest_epa_quota = {"numa-node-policy": {}} + + numa_result, epa_vcpu_set_result = Ns._process_guest_epa_numa_params( + guest_epa_quota=guest_epa_quota, + ) + + self.assertDictEqual(expected_numa_result, numa_result) + self.assertEqual(expected_epa_vcpu_set_result, epa_vcpu_set_result) + + def test__process_guest_epa_numa_params_with_no_node(self): + expected_numa_result = {} + expected_epa_vcpu_set_result = False + guest_epa_quota = { + "numa-node-policy": { + "node": [], + }, + } + + numa_result, epa_vcpu_set_result = Ns._process_guest_epa_numa_params( + guest_epa_quota=guest_epa_quota, + ) + + self.assertDictEqual(expected_numa_result, numa_result) + self.assertEqual(expected_epa_vcpu_set_result, epa_vcpu_set_result) + + def test__process_guest_epa_numa_params_with_1_node_num_cores(self): + expected_numa_result = {"cores": 3} + expected_epa_vcpu_set_result = True + guest_epa_quota = { + "numa-node-policy": { + "node": [ + { + "num-cores": 3, + }, + ], + }, + } + + numa_result, epa_vcpu_set_result = Ns._process_guest_epa_numa_params( + guest_epa_quota=guest_epa_quota, + ) + + self.assertDictEqual(expected_numa_result, numa_result) + self.assertEqual(expected_epa_vcpu_set_result, epa_vcpu_set_result) + + def test__process_guest_epa_numa_params_with_1_node_paired_threads(self): + expected_numa_result = {"paired-threads": 3} + expected_epa_vcpu_set_result = True + guest_epa_quota = { + "numa-node-policy": { + "node": [ + { + "paired-threads": {"num-paired-threads": "3"}, + }, + ], + }, + } + + numa_result, epa_vcpu_set_result = Ns._process_guest_epa_numa_params( + guest_epa_quota=guest_epa_quota, + ) + + self.assertDictEqual(expected_numa_result, numa_result) + self.assertEqual(expected_epa_vcpu_set_result, epa_vcpu_set_result) + + def test__process_guest_epa_numa_params_with_1_node_paired_threads_ids(self): + expected_numa_result = { + "paired-threads-id": [("0", "1"), ("4", "5")], + } + expected_epa_vcpu_set_result = False + guest_epa_quota = { + "numa-node-policy": { + "node": [ + { + "paired-threads": { + "paired-thread-ids": [ + { + "thread-a": 0, + "thread-b": 1, + }, + { + "thread-a": 4, + "thread-b": 5, + }, + ], + }, + }, + ], + }, + } + + numa_result, epa_vcpu_set_result = Ns._process_guest_epa_numa_params( + guest_epa_quota=guest_epa_quota, + ) + + self.assertDictEqual(expected_numa_result, numa_result) + self.assertEqual(expected_epa_vcpu_set_result, epa_vcpu_set_result) + + def test__process_guest_epa_numa_params_with_1_node_num_threads(self): + expected_numa_result = {"threads": 3} + expected_epa_vcpu_set_result = True + guest_epa_quota = { + "numa-node-policy": { + "node": [ + { + "num-threads": "3", + }, + ], + }, + } + + numa_result, epa_vcpu_set_result = Ns._process_guest_epa_numa_params( + guest_epa_quota=guest_epa_quota, + ) + + self.assertDictEqual(expected_numa_result, numa_result) + self.assertEqual(expected_epa_vcpu_set_result, epa_vcpu_set_result) + + def test__process_guest_epa_numa_params_with_1_node_memory_mb(self): + expected_numa_result = {"memory": 2} + expected_epa_vcpu_set_result = False + guest_epa_quota = { + "numa-node-policy": { + "node": [ + { + "memory-mb": 2048, + }, + ], + }, + } + + numa_result, epa_vcpu_set_result = Ns._process_guest_epa_numa_params( + guest_epa_quota=guest_epa_quota, + ) + + self.assertDictEqual(expected_numa_result, numa_result) + self.assertEqual(expected_epa_vcpu_set_result, epa_vcpu_set_result) + + def test__process_guest_epa_numa_params_with_1_node(self): + expected_numa_result = { + "cores": 3, + "paired-threads": 3, + "paired-threads-id": [("0", "1"), ("4", "5")], + "threads": 3, + "memory": 2, + } + expected_epa_vcpu_set_result = True + guest_epa_quota = { + "numa-node-policy": { + "node": [ + { + "num-cores": 3, + "paired-threads": { + "num-paired-threads": "3", + "paired-thread-ids": [ + { + "thread-a": 0, + "thread-b": 1, + }, + { + "thread-a": 4, + "thread-b": 5, + }, + ], + }, + "num-threads": "3", + "memory-mb": 2048, + }, + ], + }, + } + + numa_result, epa_vcpu_set_result = Ns._process_guest_epa_numa_params( + guest_epa_quota=guest_epa_quota, + ) + + self.assertDictEqual(expected_numa_result, numa_result) + self.assertEqual(expected_epa_vcpu_set_result, epa_vcpu_set_result) + + def test__process_guest_epa_numa_params_with_2_nodes(self): + expected_numa_result = { + "cores": 3, + "paired-threads": 3, + "paired-threads-id": [("0", "1"), ("4", "5")], + "threads": 3, + "memory": 2, + } + expected_epa_vcpu_set_result = True + guest_epa_quota = { + "numa-node-policy": { + "node": [ + { + "num-cores": 3, + "paired-threads": { + "num-paired-threads": "3", + "paired-thread-ids": [ + { + "thread-a": 0, + "thread-b": 1, + }, + { + "thread-a": 4, + "thread-b": 5, + }, + ], + }, + "num-threads": "3", + "memory-mb": 2048, + }, + { + "num-cores": 7, + "paired-threads": { + "num-paired-threads": "7", + "paired-thread-ids": [ + { + "thread-a": 2, + "thread-b": 3, + }, + { + "thread-a": 5, + "thread-b": 6, + }, + ], + }, + "num-threads": "4", + "memory-mb": 4096, + }, + ], + }, + } + + numa_result, epa_vcpu_set_result = Ns._process_guest_epa_numa_params( + guest_epa_quota=guest_epa_quota, + ) + + self.assertDictEqual(expected_numa_result, numa_result) + self.assertEqual(expected_epa_vcpu_set_result, epa_vcpu_set_result) + + def test__process_guest_epa_cpu_pinning_params_with_empty_params(self): + expected_numa_result = {} + expected_epa_vcpu_set_result = False + guest_epa_quota = {} + vcpu_count = 0 + epa_vcpu_set = False + + numa_result, epa_vcpu_set_result = Ns._process_guest_epa_cpu_pinning_params( + guest_epa_quota=guest_epa_quota, + vcpu_count=vcpu_count, + epa_vcpu_set=epa_vcpu_set, + ) + + self.assertDictEqual(expected_numa_result, numa_result) + self.assertEqual(expected_epa_vcpu_set_result, epa_vcpu_set_result) + + def test__process_guest_epa_cpu_pinning_params_with_wrong_params(self): + expected_numa_result = {} + expected_epa_vcpu_set_result = False + guest_epa_quota = { + "no-cpu-pinning-policy": "here", + } + vcpu_count = 0 + epa_vcpu_set = False + + numa_result, epa_vcpu_set_result = Ns._process_guest_epa_cpu_pinning_params( + guest_epa_quota=guest_epa_quota, + vcpu_count=vcpu_count, + epa_vcpu_set=epa_vcpu_set, + ) + + self.assertDictEqual(expected_numa_result, numa_result) + self.assertEqual(expected_epa_vcpu_set_result, epa_vcpu_set_result) + + def test__process_guest_epa_cpu_pinning_params_with_epa_vcpu_set(self): + expected_numa_result = {} + expected_epa_vcpu_set_result = True + guest_epa_quota = { + "cpu-pinning-policy": "DEDICATED", + } + vcpu_count = 0 + epa_vcpu_set = True + + numa_result, epa_vcpu_set_result = Ns._process_guest_epa_cpu_pinning_params( + guest_epa_quota=guest_epa_quota, + vcpu_count=vcpu_count, + epa_vcpu_set=epa_vcpu_set, + ) + + self.assertDictEqual(expected_numa_result, numa_result) + self.assertEqual(expected_epa_vcpu_set_result, epa_vcpu_set_result) + + def test__process_guest_epa_cpu_pinning_params_with_threads(self): + expected_numa_result = {"threads": 3} + expected_epa_vcpu_set_result = True + guest_epa_quota = { + "cpu-pinning-policy": "DEDICATED", + "cpu-thread-pinning-policy": "PREFER", + } + vcpu_count = 3 + epa_vcpu_set = False + + numa_result, epa_vcpu_set_result = Ns._process_guest_epa_cpu_pinning_params( + guest_epa_quota=guest_epa_quota, + vcpu_count=vcpu_count, + epa_vcpu_set=epa_vcpu_set, + ) + + self.assertDictEqual(expected_numa_result, numa_result) + self.assertEqual(expected_epa_vcpu_set_result, epa_vcpu_set_result) + + def test__process_guest_epa_cpu_pinning_params(self): + expected_numa_result = {"cores": 3} + expected_epa_vcpu_set_result = True + guest_epa_quota = { + "cpu-pinning-policy": "DEDICATED", + } + vcpu_count = 3 + epa_vcpu_set = False + + numa_result, epa_vcpu_set_result = Ns._process_guest_epa_cpu_pinning_params( + guest_epa_quota=guest_epa_quota, + vcpu_count=vcpu_count, + epa_vcpu_set=epa_vcpu_set, + ) + + self.assertDictEqual(expected_numa_result, numa_result) + self.assertEqual(expected_epa_vcpu_set_result, epa_vcpu_set_result) + + @patch("osm_ng_ro.ns.Ns._process_guest_epa_quota_params") + @patch("osm_ng_ro.ns.Ns._process_guest_epa_cpu_pinning_params") + @patch("osm_ng_ro.ns.Ns._process_guest_epa_numa_params") + def test__process_guest_epa_params_with_empty_params( + self, + guest_epa_numa_params, + guest_epa_cpu_pinning_params, + guest_epa_quota_params, + ): + expected_result = {} + target_flavor = {} + + result = Ns._process_epa_params( + target_flavor=target_flavor, + ) + + self.assertDictEqual(expected_result, result) + self.assertFalse(guest_epa_numa_params.called) + self.assertFalse(guest_epa_cpu_pinning_params.called) + self.assertFalse(guest_epa_quota_params.called) + + @patch("osm_ng_ro.ns.Ns._process_guest_epa_quota_params") + @patch("osm_ng_ro.ns.Ns._process_guest_epa_cpu_pinning_params") + @patch("osm_ng_ro.ns.Ns._process_guest_epa_numa_params") + def test__process_guest_epa_params_with_wrong_params( + self, + guest_epa_numa_params, + guest_epa_cpu_pinning_params, + guest_epa_quota_params, + ): + expected_result = {} + target_flavor = { + "no-guest-epa": "here", + } + + result = Ns._process_epa_params( + target_flavor=target_flavor, + ) + + self.assertDictEqual(expected_result, result) + self.assertFalse(guest_epa_numa_params.called) + self.assertFalse(guest_epa_cpu_pinning_params.called) + self.assertFalse(guest_epa_quota_params.called) + + @patch("osm_ng_ro.ns.Ns._process_guest_epa_quota_params") + @patch("osm_ng_ro.ns.Ns._process_guest_epa_cpu_pinning_params") + @patch("osm_ng_ro.ns.Ns._process_guest_epa_numa_params") + def test__process_guest_epa_params( + self, + guest_epa_numa_params, + guest_epa_cpu_pinning_params, + guest_epa_quota_params, + ): + expected_result = {} + target_flavor = { + "guest-epa": { + "vcpu-count": 1, + }, + } + + guest_epa_numa_params.return_value = ({}, False) + guest_epa_cpu_pinning_params.return_value = ({}, False) + guest_epa_quota_params.return_value = {} + + result = Ns._process_epa_params( + target_flavor=target_flavor, + ) + + self.assertDictEqual(expected_result, result) + self.assertTrue(guest_epa_numa_params.called) + self.assertTrue(guest_epa_cpu_pinning_params.called) + self.assertTrue(guest_epa_quota_params.called) + + @patch("osm_ng_ro.ns.Ns._process_guest_epa_quota_params") + @patch("osm_ng_ro.ns.Ns._process_guest_epa_cpu_pinning_params") + @patch("osm_ng_ro.ns.Ns._process_guest_epa_numa_params") + def test__process_guest_epa_params_with_mempage_size( + self, + guest_epa_numa_params, + guest_epa_cpu_pinning_params, + guest_epa_quota_params, + ): + expected_result = { + "mempage-size": "1G", + } + target_flavor = { + "guest-epa": {"vcpu-count": 1, "mempage-size": "1G"}, + } + + guest_epa_numa_params.return_value = ({}, False) + guest_epa_cpu_pinning_params.return_value = ({}, False) + guest_epa_quota_params.return_value = {} + + result = Ns._process_epa_params( + target_flavor=target_flavor, + ) + + self.assertDictEqual(expected_result, result) + self.assertTrue(guest_epa_numa_params.called) + self.assertTrue(guest_epa_cpu_pinning_params.called) + self.assertTrue(guest_epa_quota_params.called) + + @patch("osm_ng_ro.ns.Ns._process_guest_epa_quota_params") + @patch("osm_ng_ro.ns.Ns._process_guest_epa_cpu_pinning_params") + @patch("osm_ng_ro.ns.Ns._process_guest_epa_numa_params") + def test__process_guest_epa_params_with_numa( + self, + guest_epa_numa_params, + guest_epa_cpu_pinning_params, + guest_epa_quota_params, + ): + expected_result = { + "mempage-size": "1G", + "numas": [ + { + "cores": 3, + "memory": 2, + "paired-threads": 3, + "paired-threads-id": [("0", "1"), ("4", "5")], + "threads": 3, + } + ], + "cpu-quota": {"limit": 10, "reserve": 20, "shares": 30}, + "disk-io-quota": {"limit": 10, "reserve": 20, "shares": 30}, + "mem-quota": {"limit": 10, "reserve": 20, "shares": 30}, + "vif-quota": {"limit": 10, "reserve": 20, "shares": 30}, + } + target_flavor = { + "guest-epa": { + "vcpu-count": 1, + "mempage-size": "1G", + "cpu-pinning-policy": "DEDICATED", + "cpu-thread-pinning-policy": "PREFER", + "numa-node-policy": { + "node": [ + { + "num-cores": 3, + "paired-threads": { + "num-paired-threads": "3", + "paired-thread-ids": [ + { + "thread-a": 0, + "thread-b": 1, + }, + { + "thread-a": 4, + "thread-b": 5, + }, + ], + }, + "num-threads": "3", + "memory-mb": 2048, + }, + ], + }, + "cpu-quota": { + "limit": "10", + "reserve": "20", + "shares": "30", + }, + "mem-quota": { + "limit": "10", + "reserve": "20", + "shares": "30", + }, + "disk-io-quota": { + "limit": "10", + "reserve": "20", + "shares": "30", + }, + "vif-quota": { + "limit": "10", + "reserve": "20", + "shares": "30", + }, + }, + } + + guest_epa_numa_params.return_value = ( + { + "cores": 3, + "paired-threads": 3, + "paired-threads-id": [("0", "1"), ("4", "5")], + "threads": 3, + "memory": 2, + }, + True, + ) + guest_epa_cpu_pinning_params.return_value = ( + { + "threads": 3, + }, + True, + ) + guest_epa_quota_params.return_value = { + "cpu-quota": { + "limit": 10, + "reserve": 20, + "shares": 30, + }, + "mem-quota": { + "limit": 10, + "reserve": 20, + "shares": 30, + }, + "disk-io-quota": { + "limit": 10, + "reserve": 20, + "shares": 30, + }, + "vif-quota": { + "limit": 10, + "reserve": 20, + "shares": 30, + }, + } + + result = Ns._process_epa_params( + target_flavor=target_flavor, + ) + + self.assertDictEqual(expected_result, result) + self.assertTrue(guest_epa_numa_params.called) + self.assertTrue(guest_epa_cpu_pinning_params.called) + self.assertTrue(guest_epa_quota_params.called) + + @patch("osm_ng_ro.ns.Ns._process_epa_params") + def test__process_flavor_params_with_empty_target_flavor( + self, + epa_params, + ): + target_flavor = {} + indata = {} + vim_info = {} + target_record_id = "" + + with self.assertRaises(KeyError): + Ns._process_flavor_params( + target_flavor=target_flavor, + indata=indata, + vim_info=vim_info, + target_record_id=target_record_id, + ) + + self.assertFalse(epa_params.called) + + @patch("osm_ng_ro.ns.Ns._process_epa_params") + def test__process_flavor_params_with_wrong_target_flavor( + self, + epa_params, + ): + target_flavor = { + "no-target-flavor": "here", + } + indata = {} + vim_info = {} + target_record_id = "" + + with self.assertRaises(KeyError): + Ns._process_flavor_params( + target_flavor=target_flavor, + indata=indata, + vim_info=vim_info, + target_record_id=target_record_id, + ) + + self.assertFalse(epa_params.called) + + @patch("osm_ng_ro.ns.Ns._process_epa_params") + def test__process_flavor_params_with_empty_indata( + self, + epa_params, + ): + expected_result = { + "find_params": { + "flavor_data": { + "disk": 10, + "ram": 1024, + "vcpus": 2, + }, + }, + "params": { + "flavor_data": { + "disk": 10, + "name": "test", + "ram": 1024, + "vcpus": 2, + }, + }, + } + target_flavor = { + "name": "test", + "storage-gb": "10", + "memory-mb": "1024", + "vcpu-count": "2", + } + indata = {} + vim_info = {} + target_record_id = "" + + epa_params.return_value = {} + + result = Ns._process_flavor_params( + target_flavor=target_flavor, + indata=indata, + vim_info=vim_info, + target_record_id=target_record_id, + ) + + self.assertTrue(epa_params.called) + self.assertDictEqual(result, expected_result) + + @patch("osm_ng_ro.ns.Ns._process_epa_params") + def test__process_flavor_params_with_wrong_indata( + self, + epa_params, + ): + expected_result = { + "find_params": { + "flavor_data": { + "disk": 10, + "ram": 1024, + "vcpus": 2, + }, + }, + "params": { + "flavor_data": { + "disk": 10, + "name": "test", + "ram": 1024, + "vcpus": 2, + }, + }, + } + target_flavor = { + "name": "test", + "storage-gb": "10", + "memory-mb": "1024", + "vcpu-count": "2", + } + indata = { + "no-vnf": "here", + } + vim_info = {} + target_record_id = "" + + epa_params.return_value = {} + + result = Ns._process_flavor_params( + target_flavor=target_flavor, + indata=indata, + vim_info=vim_info, + target_record_id=target_record_id, + ) + + self.assertTrue(epa_params.called) + self.assertDictEqual(result, expected_result) + + @patch("osm_ng_ro.ns.Ns._process_epa_params") + def test__process_flavor_params_with_ephemeral_disk( + self, + epa_params, + ): + expected_result = { + "find_params": { + "flavor_data": { + "disk": 10, + "ram": 1024, + "vcpus": 2, + "ephemeral": 10, + }, + }, + "params": { + "flavor_data": { + "disk": 10, + "name": "test", + "ram": 1024, + "vcpus": 2, + "ephemeral": 10, + }, + }, + } + target_flavor = { + "id": "test_id", + "name": "test", + "storage-gb": "10", + "memory-mb": "1024", + "vcpu-count": "2", + } + indata = { + "vnf": [ + { + "vdur": [ + { + "ns-flavor-id": "test_id", + "virtual-storages": [ + { + "type-of-storage": "etsi-nfv-descriptors:ephemeral-storage", + "size-of-storage": "10", + }, + ], + }, + ], + }, + ], + } + vim_info = {} + target_record_id = "" + + epa_params.return_value = {} + + result = Ns._process_flavor_params( + target_flavor=target_flavor, + indata=indata, + vim_info=vim_info, + target_record_id=target_record_id, + ) + + self.assertTrue(epa_params.called) + self.assertDictEqual(result, expected_result) + + @patch("osm_ng_ro.ns.Ns._process_epa_params") + def test__process_flavor_params_with_swap_disk( + self, + epa_params, + ): + expected_result = { + "find_params": { + "flavor_data": { + "disk": 10, + "ram": 1024, + "vcpus": 2, + "swap": 20, + }, + }, + "params": { + "flavor_data": { + "disk": 10, + "name": "test", + "ram": 1024, + "vcpus": 2, + "swap": 20, + }, + }, + } + target_flavor = { + "id": "test_id", + "name": "test", + "storage-gb": "10", + "memory-mb": "1024", + "vcpu-count": "2", + } + indata = { + "vnf": [ + { + "vdur": [ + { + "ns-flavor-id": "test_id", + "virtual-storages": [ + { + "type-of-storage": "etsi-nfv-descriptors:swap-storage", + "size-of-storage": "20", + }, + ], + }, + ], + }, + ], + } + vim_info = {} + target_record_id = "" + + epa_params.return_value = {} + + result = Ns._process_flavor_params( + target_flavor=target_flavor, + indata=indata, + vim_info=vim_info, + target_record_id=target_record_id, + ) + + self.assertTrue(epa_params.called) + self.assertDictEqual(result, expected_result) + + @patch("osm_ng_ro.ns.Ns._process_epa_params") + def test__process_flavor_params_with_epa_params( + self, + epa_params, + ): + expected_result = { + "find_params": { + "flavor_data": { + "disk": 10, + "ram": 1024, + "vcpus": 2, + "extended": { + "numa": "there-is-numa-here", + }, + }, + }, + "params": { + "flavor_data": { + "disk": 10, + "name": "test", + "ram": 1024, + "vcpus": 2, + "extended": { + "numa": "there-is-numa-here", + }, + }, + }, + } + target_flavor = { + "id": "test_id", + "name": "test", + "storage-gb": "10", + "memory-mb": "1024", + "vcpu-count": "2", + } + indata = {} + vim_info = {} + target_record_id = "" + + epa_params.return_value = { + "numa": "there-is-numa-here", + } + + result = Ns._process_flavor_params( + target_flavor=target_flavor, + indata=indata, + vim_info=vim_info, + target_record_id=target_record_id, + ) + + self.assertTrue(epa_params.called) + self.assertDictEqual(result, expected_result) + + @patch("osm_ng_ro.ns.Ns._process_epa_params") + def test__process_flavor_params( + self, + epa_params, + ): + expected_result = { + "find_params": { + "flavor_data": { + "disk": 10, + "ram": 1024, + "vcpus": 2, + "ephemeral": 10, + "swap": 20, + "extended": { + "numa": "there-is-numa-here", + }, + }, + }, + "params": { + "flavor_data": { + "disk": 10, + "name": "test", + "ram": 1024, + "vcpus": 2, + "ephemeral": 10, + "swap": 20, + "extended": { + "numa": "there-is-numa-here", + }, + }, + }, + } + target_flavor = { + "id": "test_id", + "name": "test", + "storage-gb": "10", + "memory-mb": "1024", + "vcpu-count": "2", + } + indata = { + "vnf": [ + { + "vdur": [ + { + "ns-flavor-id": "test_id", + "virtual-storages": [ + { + "type-of-storage": "etsi-nfv-descriptors:ephemeral-storage", + "size-of-storage": "10", + }, + { + "type-of-storage": "etsi-nfv-descriptors:swap-storage", + "size-of-storage": "20", + }, + ], + }, + ], + }, + ], + } + vim_info = {} + target_record_id = "" + + epa_params.return_value = { + "numa": "there-is-numa-here", + } + + result = Ns._process_flavor_params( + target_flavor=target_flavor, + indata=indata, + vim_info=vim_info, + target_record_id=target_record_id, + ) + + self.assertTrue(epa_params.called) + self.assertDictEqual(result, expected_result) diff --git a/releasenotes/notes/extracting_process_flavor_params-b7251cf725adcc8f.yaml b/releasenotes/notes/extracting_process_flavor_params-b7251cf725adcc8f.yaml new file mode 100644 index 00000000..260ea4f6 --- /dev/null +++ b/releasenotes/notes/extracting_process_flavor_params-b7251cf725adcc8f.yaml @@ -0,0 +1,25 @@ +####################################################################################### +# Copyright ETSI Contributors and Others. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or +# implied. +# See the License for the specific language governing permissions and +# limitations under the License. +####################################################################################### +--- +other: + - | + Extraction of _process_flavor_params() from being a nested function inside Ns.deploy(). + The _process_flavor_params() function is now a static method inside the Ns class. This + eases the testability of _process_flavor_params(). During the extraction process, two + auxiliary functions were created/extracted from code within _process_flavor_params. The + aforementioned functions are: _process_guest_epa_quota_params() and _process_guest_epa_params(). + With this extraction a unit test was introduced to cover the extracted function. diff --git a/tox.ini b/tox.ini index 4e4985b7..c13bc92c 100644 --- a/tox.ini +++ b/tox.ini @@ -140,7 +140,7 @@ commands = deps = flake8 skip_install = true commands = - - flake8 NG-RO/osm_ng_ro/ NG-RO/setup.py + flake8 NG-RO/osm_ng_ro/ NG-RO/setup.py - flake8 RO-plugin/osm_ro_plugin/ RO-plugin/setup.py - flake8 RO-SDN-arista_cloudvision/osm_rosdn_arista_cloudvision/ RO-SDN-arista_cloudvision/setup.py - flake8 RO-SDN-dpb/osm_rosdn_dpb/ RO-SDN-dpb/setup.py