X-Git-Url: https://osm.etsi.org/gitweb/?p=osm%2FRO.git;a=blobdiff_plain;f=NG-RO%2Fosm_ng_ro%2Ftests%2Ftest_ns.py;h=eb43d1798a65f8936e3acde459fabce882ca9b4d;hp=3fa617b902757aaf33ce4a5a9a9309caaac6f843;hb=a4bac081f55423cf56e417d3540a6c38dee45e5b;hpb=839e5ca652d48ee67929d3022e4cddbf19e7ddde diff --git a/NG-RO/osm_ng_ro/tests/test_ns.py b/NG-RO/osm_ng_ro/tests/test_ns.py index 3fa617b9..eb43d179 100644 --- a/NG-RO/osm_ng_ro/tests/test_ns.py +++ b/NG-RO/osm_ng_ro/tests/test_ns.py @@ -29,6 +29,36 @@ class TestNs(unittest.TestCase): def setUp(self): pass + def test__create_task_without_extra_dict(self): + expected_result = { + "target_id": "vim_openstack_1", + "action_id": "123456", + "nsr_id": "654321", + "task_id": "123456:1", + "status": "SCHEDULED", + "action": "CREATE", + "item": "test_item", + "target_record": "test_target_record", + "target_record_id": "test_target_record_id", + } + deployment_info = { + "action_id": "123456", + "nsr_id": "654321", + "task_index": 1, + } + + task = Ns._create_task( + deployment_info=deployment_info, + target_id="vim_openstack_1", + item="test_item", + action="CREATE", + target_record="test_target_record", + target_record_id="test_target_record_id", + ) + + self.assertEqual(deployment_info.get("task_index"), 2) + self.assertDictEqual(task, expected_result) + def test__create_task(self): expected_result = { "target_id": "vim_openstack_1", @@ -113,3 +143,1851 @@ class TestNs(unittest.TestCase): ) self.assertDictEqual(ro_task, expected_result) + + def test__process_image_params_with_empty_target_image(self): + expected_result = { + "find_params": {}, + } + target_image = {} + + result = Ns._process_image_params( + target_image=target_image, + indata=None, + vim_info=None, + target_record_id=None, + ) + + self.assertDictEqual(expected_result, result) + + def test__process_image_params_with_wrong_target_image(self): + expected_result = { + "find_params": {}, + } + target_image = { + "no_image": "to_see_here", + } + + result = Ns._process_image_params( + target_image=target_image, + indata=None, + vim_info=None, + target_record_id=None, + ) + + self.assertDictEqual(expected_result, result) + + def test__process_image_params_with_image(self): + expected_result = { + "find_params": { + "filter_dict": { + "name": "cirros", + }, + }, + } + target_image = { + "image": "cirros", + } + + result = Ns._process_image_params( + target_image=target_image, + indata=None, + vim_info=None, + target_record_id=None, + ) + + self.assertDictEqual(expected_result, result) + + def test__process_image_params_with_vim_image_id(self): + expected_result = { + "find_params": { + "filter_dict": { + "id": "123456", + }, + }, + } + target_image = { + "vim_image_id": "123456", + } + + result = Ns._process_image_params( + target_image=target_image, + indata=None, + vim_info=None, + target_record_id=None, + ) + + self.assertDictEqual(expected_result, result) + + def test__process_image_params_with_image_checksum(self): + expected_result = { + "find_params": { + "filter_dict": { + "checksum": "e3fc50a88d0a364313df4b21ef20c29e", + }, + }, + } + target_image = { + "image_checksum": "e3fc50a88d0a364313df4b21ef20c29e", + } + + result = Ns._process_image_params( + target_image=target_image, + indata=None, + vim_info=None, + target_record_id=None, + ) + + self.assertDictEqual(expected_result, result) + + def test__get_resource_allocation_params_with_empty_target_image(self): + expected_result = {} + quota_descriptor = {} + + result = Ns._get_resource_allocation_params( + quota_descriptor=quota_descriptor, + ) + + self.assertDictEqual(expected_result, result) + + def test__get_resource_allocation_params_with_wrong_target_image(self): + expected_result = {} + quota_descriptor = { + "no_quota": "present_here", + } + + result = Ns._get_resource_allocation_params( + quota_descriptor=quota_descriptor, + ) + + self.assertDictEqual(expected_result, result) + + def test__get_resource_allocation_params_with_limit(self): + expected_result = { + "limit": 10, + } + quota_descriptor = { + "limit": "10", + } + + result = Ns._get_resource_allocation_params( + quota_descriptor=quota_descriptor, + ) + + self.assertDictEqual(expected_result, result) + + def test__get_resource_allocation_params_with_reserve(self): + expected_result = { + "reserve": 20, + } + quota_descriptor = { + "reserve": "20", + } + + result = Ns._get_resource_allocation_params( + quota_descriptor=quota_descriptor, + ) + + self.assertDictEqual(expected_result, result) + + def test__get_resource_allocation_params_with_shares(self): + expected_result = { + "shares": 30, + } + quota_descriptor = { + "shares": "30", + } + + result = Ns._get_resource_allocation_params( + quota_descriptor=quota_descriptor, + ) + + self.assertDictEqual(expected_result, result) + + def test__get_resource_allocation_params(self): + expected_result = { + "limit": 10, + "reserve": 20, + "shares": 30, + } + quota_descriptor = { + "limit": "10", + "reserve": "20", + "shares": "30", + } + + result = Ns._get_resource_allocation_params( + quota_descriptor=quota_descriptor, + ) + + 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) + + def test__ip_profile_to_ro_with_none(self): + ip_profile = None + + result = Ns._ip_profile_to_ro( + ip_profile=ip_profile, + ) + + self.assertIsNone(result) + + def test__ip_profile_to_ro_with_empty_profile(self): + ip_profile = {} + + result = Ns._ip_profile_to_ro( + ip_profile=ip_profile, + ) + + self.assertIsNone(result) + + def test__ip_profile_to_ro_with_wrong_profile(self): + ip_profile = { + "no-profile": "here", + } + expected_result = { + "ip_version": "IPv4", + "subnet_address": None, + "gateway_address": None, + "dhcp_enabled": False, + "dhcp_start_address": None, + "dhcp_count": None, + } + + result = Ns._ip_profile_to_ro( + ip_profile=ip_profile, + ) + + self.assertDictEqual(expected_result, result) + + def test__ip_profile_to_ro_with_ipv4_profile(self): + ip_profile = { + "ip-version": "ipv4", + "subnet-address": "192.168.0.0/24", + "gateway-address": "192.168.0.254", + "dhcp-params": { + "enabled": True, + "start-address": "192.168.0.10", + "count": 25, + }, + } + expected_result = { + "ip_version": "IPv4", + "subnet_address": "192.168.0.0/24", + "gateway_address": "192.168.0.254", + "dhcp_enabled": True, + "dhcp_start_address": "192.168.0.10", + "dhcp_count": 25, + } + + result = Ns._ip_profile_to_ro( + ip_profile=ip_profile, + ) + + self.assertDictEqual(expected_result, result) + + def test__ip_profile_to_ro_with_ipv6_profile(self): + ip_profile = { + "ip-version": "ipv6", + "subnet-address": "2001:0200:0001::/48", + "gateway-address": "2001:0200:0001:ffff:ffff:ffff:ffff:fffe", + "dhcp-params": { + "enabled": True, + "start-address": "2001:0200:0001::0010", + "count": 25, + }, + } + expected_result = { + "ip_version": "IPv6", + "subnet_address": "2001:0200:0001::/48", + "gateway_address": "2001:0200:0001:ffff:ffff:ffff:ffff:fffe", + "dhcp_enabled": True, + "dhcp_start_address": "2001:0200:0001::0010", + "dhcp_count": 25, + } + + result = Ns._ip_profile_to_ro( + ip_profile=ip_profile, + ) + + self.assertDictEqual(expected_result, result) + + def test__ip_profile_to_ro_with_dns_server(self): + ip_profile = { + "ip-version": "ipv4", + "subnet-address": "192.168.0.0/24", + "gateway-address": "192.168.0.254", + "dhcp-params": { + "enabled": True, + "start-address": "192.168.0.10", + "count": 25, + }, + "dns-server": [ + { + "address": "8.8.8.8", + }, + { + "address": "1.1.1.1", + }, + { + "address": "1.0.0.1", + }, + ], + } + expected_result = { + "ip_version": "IPv4", + "subnet_address": "192.168.0.0/24", + "gateway_address": "192.168.0.254", + "dhcp_enabled": True, + "dhcp_start_address": "192.168.0.10", + "dhcp_count": 25, + "dns_address": "8.8.8.8;1.1.1.1;1.0.0.1", + } + + result = Ns._ip_profile_to_ro( + ip_profile=ip_profile, + ) + + self.assertDictEqual(expected_result, result) + + def test__ip_profile_to_ro_with_security_group(self): + ip_profile = { + "ip-version": "ipv4", + "subnet-address": "192.168.0.0/24", + "gateway-address": "192.168.0.254", + "dhcp-params": { + "enabled": True, + "start-address": "192.168.0.10", + "count": 25, + }, + "security-group": { + "some-security-group": "here", + }, + } + expected_result = { + "ip_version": "IPv4", + "subnet_address": "192.168.0.0/24", + "gateway_address": "192.168.0.254", + "dhcp_enabled": True, + "dhcp_start_address": "192.168.0.10", + "dhcp_count": 25, + "security_group": { + "some-security-group": "here", + }, + } + + result = Ns._ip_profile_to_ro( + ip_profile=ip_profile, + ) + + self.assertDictEqual(expected_result, result) + + def test__ip_profile_to_ro(self): + ip_profile = { + "ip-version": "ipv4", + "subnet-address": "192.168.0.0/24", + "gateway-address": "192.168.0.254", + "dhcp-params": { + "enabled": True, + "start-address": "192.168.0.10", + "count": 25, + }, + "dns-server": [ + { + "address": "8.8.8.8", + }, + { + "address": "1.1.1.1", + }, + { + "address": "1.0.0.1", + }, + ], + "security-group": { + "some-security-group": "here", + }, + } + expected_result = { + "ip_version": "IPv4", + "subnet_address": "192.168.0.0/24", + "gateway_address": "192.168.0.254", + "dhcp_enabled": True, + "dhcp_start_address": "192.168.0.10", + "dhcp_count": 25, + "dns_address": "8.8.8.8;1.1.1.1;1.0.0.1", + "security_group": { + "some-security-group": "here", + }, + } + + result = Ns._ip_profile_to_ro( + ip_profile=ip_profile, + ) + + self.assertDictEqual(expected_result, result)