result = Ns._process_image_params(
target_image=target_image,
+ indata=None,
vim_info=None,
target_record_id=None,
)
result = Ns._process_image_params(
target_image=target_image,
+ indata=None,
vim_info=None,
target_record_id=None,
)
result = Ns._process_image_params(
target_image=target_image,
+ indata=None,
vim_info=None,
target_record_id=None,
)
result = Ns._process_image_params(
target_image=target_image,
+ indata=None,
vim_info=None,
target_record_id=None,
)
result = Ns._process_image_params(
target_image=target_image,
+ indata=None,
vim_info=None,
target_record_id=None,
)
)
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)
+
+ @patch("osm_ng_ro.ns.Ns._ip_profile_to_ro")
+ def test__process_net_params_with_empty_params(
+ self,
+ ip_profile_to_ro,
+ ):
+ target_vld = {
+ "name": "vld-name",
+ }
+ indata = {
+ "name": "ns-name",
+ }
+ vim_info = {
+ "provider_network": "some-profile-here",
+ }
+ target_record_id = ""
+ expected_result = {
+ "params": {
+ "net_name": "ns-name-vld-name",
+ "net_type": "bridge",
+ "ip_profile": {
+ "some_ip_profile": "here",
+ },
+ "provider_network_profile": "some-profile-here",
+ }
+ }
+
+ ip_profile_to_ro.return_value = {
+ "some_ip_profile": "here",
+ }
+
+ result = Ns._process_net_params(
+ target_vld=target_vld,
+ indata=indata,
+ vim_info=vim_info,
+ target_record_id=target_record_id,
+ )
+
+ self.assertDictEqual(expected_result, result)
+ self.assertTrue(ip_profile_to_ro.called)
+
+ @patch("osm_ng_ro.ns.Ns._ip_profile_to_ro")
+ def test__process_net_params_with_vim_info_sdn(
+ self,
+ ip_profile_to_ro,
+ ):
+ target_vld = {
+ "name": "vld-name",
+ }
+ indata = {
+ "name": "ns-name",
+ }
+ vim_info = {
+ "sdn": "some-sdn",
+ "sdn-ports": ["some", "ports", "here"],
+ "vlds": ["some", "vlds", "here"],
+ "type": "sdn-type",
+ }
+ target_record_id = "vld.sdn.something"
+ expected_result = {
+ "params": {
+ "sdn-ports": ["some", "ports", "here"],
+ "vlds": ["some", "vlds", "here"],
+ "type": "sdn-type",
+ }
+ }
+
+ result = Ns._process_net_params(
+ target_vld=target_vld,
+ indata=indata,
+ vim_info=vim_info,
+ target_record_id=target_record_id,
+ )
+
+ self.assertDictEqual(expected_result, result)
+ self.assertFalse(ip_profile_to_ro.called)
+
+ @patch("osm_ng_ro.ns.Ns._ip_profile_to_ro")
+ def test__process_net_params_with_vim_info_sdn_target_vim(
+ self,
+ ip_profile_to_ro,
+ ):
+ target_vld = {
+ "name": "vld-name",
+ }
+ indata = {
+ "name": "ns-name",
+ }
+ vim_info = {
+ "sdn": "some-sdn",
+ "sdn-ports": ["some", "ports", "here"],
+ "vlds": ["some", "vlds", "here"],
+ "target_vim": "some-vim",
+ "type": "sdn-type",
+ }
+ target_record_id = "vld.sdn.something"
+ expected_result = {
+ "depends_on": ["some-vim vld.sdn"],
+ "params": {
+ "sdn-ports": ["some", "ports", "here"],
+ "vlds": ["some", "vlds", "here"],
+ "target_vim": "some-vim",
+ "type": "sdn-type",
+ },
+ }
+
+ result = Ns._process_net_params(
+ target_vld=target_vld,
+ indata=indata,
+ vim_info=vim_info,
+ target_record_id=target_record_id,
+ )
+
+ self.assertDictEqual(expected_result, result)
+ self.assertFalse(ip_profile_to_ro.called)
+
+ @patch("osm_ng_ro.ns.Ns._ip_profile_to_ro")
+ def test__process_net_params_with_vim_network_name(
+ self,
+ ip_profile_to_ro,
+ ):
+ target_vld = {
+ "name": "vld-name",
+ }
+ indata = {
+ "name": "ns-name",
+ }
+ vim_info = {
+ "vim_network_name": "some-network-name",
+ }
+ target_record_id = "vld.sdn.something"
+ expected_result = {
+ "find_params": {
+ "filter_dict": {
+ "name": "some-network-name",
+ },
+ },
+ }
+
+ result = Ns._process_net_params(
+ target_vld=target_vld,
+ indata=indata,
+ vim_info=vim_info,
+ target_record_id=target_record_id,
+ )
+
+ self.assertDictEqual(expected_result, result)
+ self.assertFalse(ip_profile_to_ro.called)
+
+ @patch("osm_ng_ro.ns.Ns._ip_profile_to_ro")
+ def test__process_net_params_with_vim_network_id(
+ self,
+ ip_profile_to_ro,
+ ):
+ target_vld = {
+ "name": "vld-name",
+ }
+ indata = {
+ "name": "ns-name",
+ }
+ vim_info = {
+ "vim_network_id": "some-network-id",
+ }
+ target_record_id = "vld.sdn.something"
+ expected_result = {
+ "find_params": {
+ "filter_dict": {
+ "id": "some-network-id",
+ },
+ },
+ }
+
+ result = Ns._process_net_params(
+ target_vld=target_vld,
+ indata=indata,
+ vim_info=vim_info,
+ target_record_id=target_record_id,
+ )
+
+ self.assertDictEqual(expected_result, result)
+ self.assertFalse(ip_profile_to_ro.called)
+
+ @patch("osm_ng_ro.ns.Ns._ip_profile_to_ro")
+ def test__process_net_params_with_mgmt_network(
+ self,
+ ip_profile_to_ro,
+ ):
+ target_vld = {
+ "id": "vld-id",
+ "name": "vld-name",
+ "mgmt-network": "some-mgmt-network",
+ }
+ indata = {
+ "name": "ns-name",
+ }
+ vim_info = {}
+ target_record_id = "vld.sdn.something"
+ expected_result = {
+ "find_params": {
+ "mgmt": True,
+ "name": "vld-id",
+ },
+ }
+
+ result = Ns._process_net_params(
+ target_vld=target_vld,
+ indata=indata,
+ vim_info=vim_info,
+ target_record_id=target_record_id,
+ )
+
+ self.assertDictEqual(expected_result, result)
+ self.assertFalse(ip_profile_to_ro.called)
+
+ @patch("osm_ng_ro.ns.Ns._ip_profile_to_ro")
+ def test__process_net_params_with_underlay_eline(
+ self,
+ ip_profile_to_ro,
+ ):
+ target_vld = {
+ "name": "vld-name",
+ "underlay": "some-underlay-here",
+ "type": "ELINE",
+ }
+ indata = {
+ "name": "ns-name",
+ }
+ vim_info = {
+ "provider_network": "some-profile-here",
+ }
+ target_record_id = ""
+ expected_result = {
+ "params": {
+ "ip_profile": {
+ "some_ip_profile": "here",
+ },
+ "net_name": "ns-name-vld-name",
+ "net_type": "ptp",
+ "provider_network_profile": "some-profile-here",
+ }
+ }
+
+ ip_profile_to_ro.return_value = {
+ "some_ip_profile": "here",
+ }
+
+ result = Ns._process_net_params(
+ target_vld=target_vld,
+ indata=indata,
+ vim_info=vim_info,
+ target_record_id=target_record_id,
+ )
+
+ self.assertDictEqual(expected_result, result)
+ self.assertTrue(ip_profile_to_ro.called)
+
+ @patch("osm_ng_ro.ns.Ns._ip_profile_to_ro")
+ def test__process_net_params_with_underlay_elan(
+ self,
+ ip_profile_to_ro,
+ ):
+ target_vld = {
+ "name": "vld-name",
+ "underlay": "some-underlay-here",
+ "type": "ELAN",
+ }
+ indata = {
+ "name": "ns-name",
+ }
+ vim_info = {
+ "provider_network": "some-profile-here",
+ }
+ target_record_id = ""
+ expected_result = {
+ "params": {
+ "ip_profile": {
+ "some_ip_profile": "here",
+ },
+ "net_name": "ns-name-vld-name",
+ "net_type": "data",
+ "provider_network_profile": "some-profile-here",
+ }
+ }
+
+ ip_profile_to_ro.return_value = {
+ "some_ip_profile": "here",
+ }
+
+ result = Ns._process_net_params(
+ target_vld=target_vld,
+ indata=indata,
+ vim_info=vim_info,
+ target_record_id=target_record_id,
+ )
+
+ self.assertDictEqual(expected_result, result)
+ self.assertTrue(ip_profile_to_ro.called)