1 #######################################################################################
2 # Copyright ETSI Contributors and Others.
4 # Licensed under the Apache License, Version 2.0 (the "License");
5 # you may not use this file except in compliance with the License.
6 # You may obtain a copy of the License at
8 # http://www.apache.org/licenses/LICENSE-2.0
10 # Unless required by applicable law or agreed to in writing, software
11 # distributed under the License is distributed on an "AS IS" BASIS,
12 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
14 # See the License for the specific language governing permissions and
15 # limitations under the License.
16 #######################################################################################
19 from unittest
.mock
import Mock
, patch
21 from osm_ng_ro
.ns
import Ns
24 __author__
= "Eduardo Sousa"
25 __date__
= "$19-NOV-2021 00:00:00$"
28 class TestNs(unittest
.TestCase
):
32 def test__create_task_without_extra_dict(self
):
34 "target_id": "vim_openstack_1",
35 "action_id": "123456",
37 "task_id": "123456:1",
38 "status": "SCHEDULED",
41 "target_record": "test_target_record",
42 "target_record_id": "test_target_record_id",
45 "action_id": "123456",
50 task
= Ns
._create
_task
(
51 deployment_info
=deployment_info
,
52 target_id
="vim_openstack_1",
55 target_record
="test_target_record",
56 target_record_id
="test_target_record_id",
59 self
.assertEqual(deployment_info
.get("task_index"), 2)
60 self
.assertDictEqual(task
, expected_result
)
62 def test__create_task(self
):
64 "target_id": "vim_openstack_1",
65 "action_id": "123456",
67 "task_id": "123456:1",
68 "status": "SCHEDULED",
71 "target_record": "test_target_record",
72 "target_record_id": "test_target_record_id",
73 # values coming from extra_dict
74 "params": "test_params",
75 "find_params": "test_find_params",
76 "depends_on": "test_depends_on",
79 "action_id": "123456",
84 task
= Ns
._create
_task
(
85 deployment_info
=deployment_info
,
86 target_id
="vim_openstack_1",
89 target_record
="test_target_record",
90 target_record_id
="test_target_record_id",
92 "params": "test_params",
93 "find_params": "test_find_params",
94 "depends_on": "test_depends_on",
98 self
.assertEqual(deployment_info
.get("task_index"), 2)
99 self
.assertDictEqual(task
, expected_result
)
101 @patch("osm_ng_ro.ns.time")
102 def test__create_ro_task(self
, mock_time
: Mock
):
103 now
= 1637324838.994551
104 mock_time
.return_value
= now
106 "target_id": "vim_openstack_1",
107 "action_id": "123456",
109 "task_id": "123456:1",
110 "status": "SCHEDULED",
113 "target_record": "test_target_record",
114 "target_record_id": "test_target_record_id",
115 # values coming from extra_dict
116 "params": "test_params",
117 "find_params": "test_find_params",
118 "depends_on": "test_depends_on",
124 "target_id": "vim_openstack_1",
127 "created_items": None,
140 ro_task
= Ns
._create
_ro
_task
(
141 target_id
="vim_openstack_1",
145 self
.assertDictEqual(ro_task
, expected_result
)
147 def test__process_image_params_with_empty_target_image(self
):
153 result
= Ns
._process
_image
_params
(
154 target_image
=target_image
,
157 target_record_id
=None,
160 self
.assertDictEqual(expected_result
, result
)
162 def test__process_image_params_with_wrong_target_image(self
):
167 "no_image": "to_see_here",
170 result
= Ns
._process
_image
_params
(
171 target_image
=target_image
,
174 target_record_id
=None,
177 self
.assertDictEqual(expected_result
, result
)
179 def test__process_image_params_with_image(self
):
191 result
= Ns
._process
_image
_params
(
192 target_image
=target_image
,
195 target_record_id
=None,
198 self
.assertDictEqual(expected_result
, result
)
200 def test__process_image_params_with_vim_image_id(self
):
209 "vim_image_id": "123456",
212 result
= Ns
._process
_image
_params
(
213 target_image
=target_image
,
216 target_record_id
=None,
219 self
.assertDictEqual(expected_result
, result
)
221 def test__process_image_params_with_image_checksum(self
):
225 "checksum": "e3fc50a88d0a364313df4b21ef20c29e",
230 "image_checksum": "e3fc50a88d0a364313df4b21ef20c29e",
233 result
= Ns
._process
_image
_params
(
234 target_image
=target_image
,
237 target_record_id
=None,
240 self
.assertDictEqual(expected_result
, result
)
242 def test__get_resource_allocation_params_with_empty_target_image(self
):
244 quota_descriptor
= {}
246 result
= Ns
._get
_resource
_allocation
_params
(
247 quota_descriptor
=quota_descriptor
,
250 self
.assertDictEqual(expected_result
, result
)
252 def test__get_resource_allocation_params_with_wrong_target_image(self
):
255 "no_quota": "present_here",
258 result
= Ns
._get
_resource
_allocation
_params
(
259 quota_descriptor
=quota_descriptor
,
262 self
.assertDictEqual(expected_result
, result
)
264 def test__get_resource_allocation_params_with_limit(self
):
272 result
= Ns
._get
_resource
_allocation
_params
(
273 quota_descriptor
=quota_descriptor
,
276 self
.assertDictEqual(expected_result
, result
)
278 def test__get_resource_allocation_params_with_reserve(self
):
286 result
= Ns
._get
_resource
_allocation
_params
(
287 quota_descriptor
=quota_descriptor
,
290 self
.assertDictEqual(expected_result
, result
)
292 def test__get_resource_allocation_params_with_shares(self
):
300 result
= Ns
._get
_resource
_allocation
_params
(
301 quota_descriptor
=quota_descriptor
,
304 self
.assertDictEqual(expected_result
, result
)
306 def test__get_resource_allocation_params(self
):
318 result
= Ns
._get
_resource
_allocation
_params
(
319 quota_descriptor
=quota_descriptor
,
322 self
.assertDictEqual(expected_result
, result
)
324 @patch("osm_ng_ro.ns.Ns._get_resource_allocation_params")
325 def test__process_guest_epa_quota_params_with_empty_quota_epa_cpu(
333 result
= Ns
._process
_guest
_epa
_quota
_params
(
334 guest_epa_quota
=guest_epa_quota
,
335 epa_vcpu_set
=epa_vcpu_set
,
338 self
.assertDictEqual(expected_result
, result
)
339 self
.assertFalse(resource_allocation
.called
)
341 @patch("osm_ng_ro.ns.Ns._get_resource_allocation_params")
342 def test__process_guest_epa_quota_params_with_empty_quota_false_epa_cpu(
350 result
= Ns
._process
_guest
_epa
_quota
_params
(
351 guest_epa_quota
=guest_epa_quota
,
352 epa_vcpu_set
=epa_vcpu_set
,
355 self
.assertDictEqual(expected_result
, result
)
356 self
.assertFalse(resource_allocation
.called
)
358 @patch("osm_ng_ro.ns.Ns._get_resource_allocation_params")
359 def test__process_guest_epa_quota_params_with_wrong_quota_epa_cpu(
365 "no-quota": "nothing",
369 result
= Ns
._process
_guest
_epa
_quota
_params
(
370 guest_epa_quota
=guest_epa_quota
,
371 epa_vcpu_set
=epa_vcpu_set
,
374 self
.assertDictEqual(expected_result
, result
)
375 self
.assertFalse(resource_allocation
.called
)
377 @patch("osm_ng_ro.ns.Ns._get_resource_allocation_params")
378 def test__process_guest_epa_quota_params_with_wrong_quota_false_epa_cpu(
384 "no-quota": "nothing",
388 result
= Ns
._process
_guest
_epa
_quota
_params
(
389 guest_epa_quota
=guest_epa_quota
,
390 epa_vcpu_set
=epa_vcpu_set
,
393 self
.assertDictEqual(expected_result
, result
)
394 self
.assertFalse(resource_allocation
.called
)
396 @patch("osm_ng_ro.ns.Ns._get_resource_allocation_params")
397 def test__process_guest_epa_quota_params_with_cpu_quota_epa_cpu(
411 result
= Ns
._process
_guest
_epa
_quota
_params
(
412 guest_epa_quota
=guest_epa_quota
,
413 epa_vcpu_set
=epa_vcpu_set
,
416 self
.assertDictEqual(expected_result
, result
)
417 self
.assertFalse(resource_allocation
.called
)
419 @patch("osm_ng_ro.ns.Ns._get_resource_allocation_params")
420 def test__process_guest_epa_quota_params_with_cpu_quota_false_epa_cpu(
440 resource_allocation_param
= {
445 resource_allocation
.return_value
= {
451 result
= Ns
._process
_guest
_epa
_quota
_params
(
452 guest_epa_quota
=guest_epa_quota
,
453 epa_vcpu_set
=epa_vcpu_set
,
456 resource_allocation
.assert_called_once_with(resource_allocation_param
)
457 self
.assertDictEqual(expected_result
, result
)
459 @patch("osm_ng_ro.ns.Ns._get_resource_allocation_params")
460 def test__process_guest_epa_quota_params_with_mem_quota_epa_cpu(
480 resource_allocation_param
= {
485 resource_allocation
.return_value
= {
491 result
= Ns
._process
_guest
_epa
_quota
_params
(
492 guest_epa_quota
=guest_epa_quota
,
493 epa_vcpu_set
=epa_vcpu_set
,
496 resource_allocation
.assert_called_once_with(resource_allocation_param
)
497 self
.assertDictEqual(expected_result
, result
)
499 @patch("osm_ng_ro.ns.Ns._get_resource_allocation_params")
500 def test__process_guest_epa_quota_params_with_mem_quota_false_epa_cpu(
520 resource_allocation_param
= {
525 resource_allocation
.return_value
= {
531 result
= Ns
._process
_guest
_epa
_quota
_params
(
532 guest_epa_quota
=guest_epa_quota
,
533 epa_vcpu_set
=epa_vcpu_set
,
536 resource_allocation
.assert_called_once_with(resource_allocation_param
)
537 self
.assertDictEqual(expected_result
, result
)
539 @patch("osm_ng_ro.ns.Ns._get_resource_allocation_params")
540 def test__process_guest_epa_quota_params_with_disk_io_quota_epa_cpu(
560 resource_allocation_param
= {
565 resource_allocation
.return_value
= {
571 result
= Ns
._process
_guest
_epa
_quota
_params
(
572 guest_epa_quota
=guest_epa_quota
,
573 epa_vcpu_set
=epa_vcpu_set
,
576 resource_allocation
.assert_called_once_with(resource_allocation_param
)
577 self
.assertDictEqual(expected_result
, result
)
579 @patch("osm_ng_ro.ns.Ns._get_resource_allocation_params")
580 def test__process_guest_epa_quota_params_with_disk_io_quota_false_epa_cpu(
600 resource_allocation_param
= {
605 resource_allocation
.return_value
= {
611 result
= Ns
._process
_guest
_epa
_quota
_params
(
612 guest_epa_quota
=guest_epa_quota
,
613 epa_vcpu_set
=epa_vcpu_set
,
616 resource_allocation
.assert_called_once_with(resource_allocation_param
)
617 self
.assertDictEqual(expected_result
, result
)
619 @patch("osm_ng_ro.ns.Ns._get_resource_allocation_params")
620 def test__process_guest_epa_quota_params_with_vif_quota_epa_cpu(
640 resource_allocation_param
= {
645 resource_allocation
.return_value
= {
651 result
= Ns
._process
_guest
_epa
_quota
_params
(
652 guest_epa_quota
=guest_epa_quota
,
653 epa_vcpu_set
=epa_vcpu_set
,
656 resource_allocation
.assert_called_once_with(resource_allocation_param
)
657 self
.assertDictEqual(expected_result
, result
)
659 @patch("osm_ng_ro.ns.Ns._get_resource_allocation_params")
660 def test__process_guest_epa_quota_params_with_vif_quota_false_epa_cpu(
680 resource_allocation_param
= {
685 resource_allocation
.return_value
= {
691 result
= Ns
._process
_guest
_epa
_quota
_params
(
692 guest_epa_quota
=guest_epa_quota
,
693 epa_vcpu_set
=epa_vcpu_set
,
696 resource_allocation
.assert_called_once_with(resource_allocation_param
)
697 self
.assertDictEqual(expected_result
, result
)
699 @patch("osm_ng_ro.ns.Ns._get_resource_allocation_params")
700 def test__process_guest_epa_quota_params_with_quota_epa_cpu(
745 resource_allocation
.return_value
= {
751 result
= Ns
._process
_guest
_epa
_quota
_params
(
752 guest_epa_quota
=guest_epa_quota
,
753 epa_vcpu_set
=epa_vcpu_set
,
756 self
.assertTrue(resource_allocation
.called
)
757 self
.assertDictEqual(expected_result
, result
)
759 @patch("osm_ng_ro.ns.Ns._get_resource_allocation_params")
760 def test__process_guest_epa_quota_params_with_quota_epa_cpu_no_set(
810 resource_allocation
.return_value
= {
816 result
= Ns
._process
_guest
_epa
_quota
_params
(
817 guest_epa_quota
=guest_epa_quota
,
818 epa_vcpu_set
=epa_vcpu_set
,
821 self
.assertTrue(resource_allocation
.called
)
822 self
.assertDictEqual(expected_result
, result
)
824 def test__process_guest_epa_numa_params_with_empty_numa_params(self
):
825 expected_numa_result
= {}
826 expected_epa_vcpu_set_result
= False
829 numa_result
, epa_vcpu_set_result
= Ns
._process
_guest
_epa
_numa
_params
(
830 guest_epa_quota
=guest_epa_quota
,
833 self
.assertDictEqual(expected_numa_result
, numa_result
)
834 self
.assertEqual(expected_epa_vcpu_set_result
, epa_vcpu_set_result
)
836 def test__process_guest_epa_numa_params_with_wrong_numa_params(self
):
837 expected_numa_result
= {}
838 expected_epa_vcpu_set_result
= False
839 guest_epa_quota
= {"no_nume": "here"}
841 numa_result
, epa_vcpu_set_result
= Ns
._process
_guest
_epa
_numa
_params
(
842 guest_epa_quota
=guest_epa_quota
,
845 self
.assertDictEqual(expected_numa_result
, numa_result
)
846 self
.assertEqual(expected_epa_vcpu_set_result
, epa_vcpu_set_result
)
848 def test__process_guest_epa_numa_params_with_numa_node_policy(self
):
849 expected_numa_result
= {}
850 expected_epa_vcpu_set_result
= False
851 guest_epa_quota
= {"numa-node-policy": {}}
853 numa_result
, epa_vcpu_set_result
= Ns
._process
_guest
_epa
_numa
_params
(
854 guest_epa_quota
=guest_epa_quota
,
857 self
.assertDictEqual(expected_numa_result
, numa_result
)
858 self
.assertEqual(expected_epa_vcpu_set_result
, epa_vcpu_set_result
)
860 def test__process_guest_epa_numa_params_with_no_node(self
):
861 expected_numa_result
= {}
862 expected_epa_vcpu_set_result
= False
864 "numa-node-policy": {
869 numa_result
, epa_vcpu_set_result
= Ns
._process
_guest
_epa
_numa
_params
(
870 guest_epa_quota
=guest_epa_quota
,
873 self
.assertDictEqual(expected_numa_result
, numa_result
)
874 self
.assertEqual(expected_epa_vcpu_set_result
, epa_vcpu_set_result
)
876 def test__process_guest_epa_numa_params_with_1_node_num_cores(self
):
877 expected_numa_result
= {"cores": 3}
878 expected_epa_vcpu_set_result
= True
880 "numa-node-policy": {
889 numa_result
, epa_vcpu_set_result
= Ns
._process
_guest
_epa
_numa
_params
(
890 guest_epa_quota
=guest_epa_quota
,
893 self
.assertDictEqual(expected_numa_result
, numa_result
)
894 self
.assertEqual(expected_epa_vcpu_set_result
, epa_vcpu_set_result
)
896 def test__process_guest_epa_numa_params_with_1_node_paired_threads(self
):
897 expected_numa_result
= {"paired-threads": 3}
898 expected_epa_vcpu_set_result
= True
900 "numa-node-policy": {
903 "paired-threads": {"num-paired-threads": "3"},
909 numa_result
, epa_vcpu_set_result
= Ns
._process
_guest
_epa
_numa
_params
(
910 guest_epa_quota
=guest_epa_quota
,
913 self
.assertDictEqual(expected_numa_result
, numa_result
)
914 self
.assertEqual(expected_epa_vcpu_set_result
, epa_vcpu_set_result
)
916 def test__process_guest_epa_numa_params_with_1_node_paired_threads_ids(self
):
917 expected_numa_result
= {
918 "paired-threads-id": [("0", "1"), ("4", "5")],
920 expected_epa_vcpu_set_result
= False
922 "numa-node-policy": {
926 "paired-thread-ids": [
942 numa_result
, epa_vcpu_set_result
= Ns
._process
_guest
_epa
_numa
_params
(
943 guest_epa_quota
=guest_epa_quota
,
946 self
.assertDictEqual(expected_numa_result
, numa_result
)
947 self
.assertEqual(expected_epa_vcpu_set_result
, epa_vcpu_set_result
)
949 def test__process_guest_epa_numa_params_with_1_node_num_threads(self
):
950 expected_numa_result
= {"threads": 3}
951 expected_epa_vcpu_set_result
= True
953 "numa-node-policy": {
962 numa_result
, epa_vcpu_set_result
= Ns
._process
_guest
_epa
_numa
_params
(
963 guest_epa_quota
=guest_epa_quota
,
966 self
.assertDictEqual(expected_numa_result
, numa_result
)
967 self
.assertEqual(expected_epa_vcpu_set_result
, epa_vcpu_set_result
)
969 def test__process_guest_epa_numa_params_with_1_node_memory_mb(self
):
970 expected_numa_result
= {"memory": 2}
971 expected_epa_vcpu_set_result
= False
973 "numa-node-policy": {
982 numa_result
, epa_vcpu_set_result
= Ns
._process
_guest
_epa
_numa
_params
(
983 guest_epa_quota
=guest_epa_quota
,
986 self
.assertDictEqual(expected_numa_result
, numa_result
)
987 self
.assertEqual(expected_epa_vcpu_set_result
, epa_vcpu_set_result
)
989 def test__process_guest_epa_numa_params_with_1_node(self
):
990 expected_numa_result
= {
993 "paired-threads-id": [("0", "1"), ("4", "5")],
997 expected_epa_vcpu_set_result
= True
999 "numa-node-policy": {
1004 "num-paired-threads": "3",
1005 "paired-thread-ids": [
1023 numa_result
, epa_vcpu_set_result
= Ns
._process
_guest
_epa
_numa
_params
(
1024 guest_epa_quota
=guest_epa_quota
,
1027 self
.assertDictEqual(expected_numa_result
, numa_result
)
1028 self
.assertEqual(expected_epa_vcpu_set_result
, epa_vcpu_set_result
)
1030 def test__process_guest_epa_numa_params_with_2_nodes(self
):
1031 expected_numa_result
= {
1033 "paired-threads": 3,
1034 "paired-threads-id": [("0", "1"), ("4", "5")],
1038 expected_epa_vcpu_set_result
= True
1040 "numa-node-policy": {
1045 "num-paired-threads": "3",
1046 "paired-thread-ids": [
1063 "num-paired-threads": "7",
1064 "paired-thread-ids": [
1082 numa_result
, epa_vcpu_set_result
= Ns
._process
_guest
_epa
_numa
_params
(
1083 guest_epa_quota
=guest_epa_quota
,
1086 self
.assertDictEqual(expected_numa_result
, numa_result
)
1087 self
.assertEqual(expected_epa_vcpu_set_result
, epa_vcpu_set_result
)
1089 def test__process_guest_epa_cpu_pinning_params_with_empty_params(self
):
1090 expected_numa_result
= {}
1091 expected_epa_vcpu_set_result
= False
1092 guest_epa_quota
= {}
1094 epa_vcpu_set
= False
1096 numa_result
, epa_vcpu_set_result
= Ns
._process
_guest
_epa
_cpu
_pinning
_params
(
1097 guest_epa_quota
=guest_epa_quota
,
1098 vcpu_count
=vcpu_count
,
1099 epa_vcpu_set
=epa_vcpu_set
,
1102 self
.assertDictEqual(expected_numa_result
, numa_result
)
1103 self
.assertEqual(expected_epa_vcpu_set_result
, epa_vcpu_set_result
)
1105 def test__process_guest_epa_cpu_pinning_params_with_wrong_params(self
):
1106 expected_numa_result
= {}
1107 expected_epa_vcpu_set_result
= False
1109 "no-cpu-pinning-policy": "here",
1112 epa_vcpu_set
= False
1114 numa_result
, epa_vcpu_set_result
= Ns
._process
_guest
_epa
_cpu
_pinning
_params
(
1115 guest_epa_quota
=guest_epa_quota
,
1116 vcpu_count
=vcpu_count
,
1117 epa_vcpu_set
=epa_vcpu_set
,
1120 self
.assertDictEqual(expected_numa_result
, numa_result
)
1121 self
.assertEqual(expected_epa_vcpu_set_result
, epa_vcpu_set_result
)
1123 def test__process_guest_epa_cpu_pinning_params_with_epa_vcpu_set(self
):
1124 expected_numa_result
= {}
1125 expected_epa_vcpu_set_result
= True
1127 "cpu-pinning-policy": "DEDICATED",
1132 numa_result
, epa_vcpu_set_result
= Ns
._process
_guest
_epa
_cpu
_pinning
_params
(
1133 guest_epa_quota
=guest_epa_quota
,
1134 vcpu_count
=vcpu_count
,
1135 epa_vcpu_set
=epa_vcpu_set
,
1138 self
.assertDictEqual(expected_numa_result
, numa_result
)
1139 self
.assertEqual(expected_epa_vcpu_set_result
, epa_vcpu_set_result
)
1141 def test__process_guest_epa_cpu_pinning_params_with_threads(self
):
1142 expected_numa_result
= {"threads": 3}
1143 expected_epa_vcpu_set_result
= True
1145 "cpu-pinning-policy": "DEDICATED",
1146 "cpu-thread-pinning-policy": "PREFER",
1149 epa_vcpu_set
= False
1151 numa_result
, epa_vcpu_set_result
= Ns
._process
_guest
_epa
_cpu
_pinning
_params
(
1152 guest_epa_quota
=guest_epa_quota
,
1153 vcpu_count
=vcpu_count
,
1154 epa_vcpu_set
=epa_vcpu_set
,
1157 self
.assertDictEqual(expected_numa_result
, numa_result
)
1158 self
.assertEqual(expected_epa_vcpu_set_result
, epa_vcpu_set_result
)
1160 def test__process_guest_epa_cpu_pinning_params(self
):
1161 expected_numa_result
= {"cores": 3}
1162 expected_epa_vcpu_set_result
= True
1164 "cpu-pinning-policy": "DEDICATED",
1167 epa_vcpu_set
= False
1169 numa_result
, epa_vcpu_set_result
= Ns
._process
_guest
_epa
_cpu
_pinning
_params
(
1170 guest_epa_quota
=guest_epa_quota
,
1171 vcpu_count
=vcpu_count
,
1172 epa_vcpu_set
=epa_vcpu_set
,
1175 self
.assertDictEqual(expected_numa_result
, numa_result
)
1176 self
.assertEqual(expected_epa_vcpu_set_result
, epa_vcpu_set_result
)
1178 @patch("osm_ng_ro.ns.Ns._process_guest_epa_quota_params")
1179 @patch("osm_ng_ro.ns.Ns._process_guest_epa_cpu_pinning_params")
1180 @patch("osm_ng_ro.ns.Ns._process_guest_epa_numa_params")
1181 def test__process_guest_epa_params_with_empty_params(
1183 guest_epa_numa_params
,
1184 guest_epa_cpu_pinning_params
,
1185 guest_epa_quota_params
,
1187 expected_result
= {}
1190 result
= Ns
._process
_epa
_params
(
1191 target_flavor
=target_flavor
,
1194 self
.assertDictEqual(expected_result
, result
)
1195 self
.assertFalse(guest_epa_numa_params
.called
)
1196 self
.assertFalse(guest_epa_cpu_pinning_params
.called
)
1197 self
.assertFalse(guest_epa_quota_params
.called
)
1199 @patch("osm_ng_ro.ns.Ns._process_guest_epa_quota_params")
1200 @patch("osm_ng_ro.ns.Ns._process_guest_epa_cpu_pinning_params")
1201 @patch("osm_ng_ro.ns.Ns._process_guest_epa_numa_params")
1202 def test__process_guest_epa_params_with_wrong_params(
1204 guest_epa_numa_params
,
1205 guest_epa_cpu_pinning_params
,
1206 guest_epa_quota_params
,
1208 expected_result
= {}
1210 "no-guest-epa": "here",
1213 result
= Ns
._process
_epa
_params
(
1214 target_flavor
=target_flavor
,
1217 self
.assertDictEqual(expected_result
, result
)
1218 self
.assertFalse(guest_epa_numa_params
.called
)
1219 self
.assertFalse(guest_epa_cpu_pinning_params
.called
)
1220 self
.assertFalse(guest_epa_quota_params
.called
)
1222 @patch("osm_ng_ro.ns.Ns._process_guest_epa_quota_params")
1223 @patch("osm_ng_ro.ns.Ns._process_guest_epa_cpu_pinning_params")
1224 @patch("osm_ng_ro.ns.Ns._process_guest_epa_numa_params")
1225 def test__process_guest_epa_params(
1227 guest_epa_numa_params
,
1228 guest_epa_cpu_pinning_params
,
1229 guest_epa_quota_params
,
1231 expected_result
= {}
1238 guest_epa_numa_params
.return_value
= ({}, False)
1239 guest_epa_cpu_pinning_params
.return_value
= ({}, False)
1240 guest_epa_quota_params
.return_value
= {}
1242 result
= Ns
._process
_epa
_params
(
1243 target_flavor
=target_flavor
,
1246 self
.assertDictEqual(expected_result
, result
)
1247 self
.assertTrue(guest_epa_numa_params
.called
)
1248 self
.assertTrue(guest_epa_cpu_pinning_params
.called
)
1249 self
.assertTrue(guest_epa_quota_params
.called
)
1251 @patch("osm_ng_ro.ns.Ns._process_guest_epa_quota_params")
1252 @patch("osm_ng_ro.ns.Ns._process_guest_epa_cpu_pinning_params")
1253 @patch("osm_ng_ro.ns.Ns._process_guest_epa_numa_params")
1254 def test__process_guest_epa_params_with_mempage_size(
1256 guest_epa_numa_params
,
1257 guest_epa_cpu_pinning_params
,
1258 guest_epa_quota_params
,
1261 "mempage-size": "1G",
1264 "guest-epa": {"vcpu-count": 1, "mempage-size": "1G"},
1267 guest_epa_numa_params
.return_value
= ({}, False)
1268 guest_epa_cpu_pinning_params
.return_value
= ({}, False)
1269 guest_epa_quota_params
.return_value
= {}
1271 result
= Ns
._process
_epa
_params
(
1272 target_flavor
=target_flavor
,
1275 self
.assertDictEqual(expected_result
, result
)
1276 self
.assertTrue(guest_epa_numa_params
.called
)
1277 self
.assertTrue(guest_epa_cpu_pinning_params
.called
)
1278 self
.assertTrue(guest_epa_quota_params
.called
)
1280 @patch("osm_ng_ro.ns.Ns._process_guest_epa_quota_params")
1281 @patch("osm_ng_ro.ns.Ns._process_guest_epa_cpu_pinning_params")
1282 @patch("osm_ng_ro.ns.Ns._process_guest_epa_numa_params")
1283 def test__process_guest_epa_params_with_numa(
1285 guest_epa_numa_params
,
1286 guest_epa_cpu_pinning_params
,
1287 guest_epa_quota_params
,
1290 "mempage-size": "1G",
1295 "paired-threads": 3,
1296 "paired-threads-id": [("0", "1"), ("4", "5")],
1300 "cpu-quota": {"limit": 10, "reserve": 20, "shares": 30},
1301 "disk-io-quota": {"limit": 10, "reserve": 20, "shares": 30},
1302 "mem-quota": {"limit": 10, "reserve": 20, "shares": 30},
1303 "vif-quota": {"limit": 10, "reserve": 20, "shares": 30},
1308 "mempage-size": "1G",
1309 "cpu-pinning-policy": "DEDICATED",
1310 "cpu-thread-pinning-policy": "PREFER",
1311 "numa-node-policy": {
1316 "num-paired-threads": "3",
1317 "paired-thread-ids": [
1356 guest_epa_numa_params
.return_value
= (
1359 "paired-threads": 3,
1360 "paired-threads-id": [("0", "1"), ("4", "5")],
1366 guest_epa_cpu_pinning_params
.return_value
= (
1372 guest_epa_quota_params
.return_value
= {
1395 result
= Ns
._process
_epa
_params
(
1396 target_flavor
=target_flavor
,
1399 self
.assertDictEqual(expected_result
, result
)
1400 self
.assertTrue(guest_epa_numa_params
.called
)
1401 self
.assertTrue(guest_epa_cpu_pinning_params
.called
)
1402 self
.assertTrue(guest_epa_quota_params
.called
)
1404 @patch("osm_ng_ro.ns.Ns._process_epa_params")
1405 def test__process_flavor_params_with_empty_target_flavor(
1412 target_record_id
= ""
1414 with self
.assertRaises(KeyError):
1415 Ns
._process
_flavor
_params
(
1416 target_flavor
=target_flavor
,
1419 target_record_id
=target_record_id
,
1422 self
.assertFalse(epa_params
.called
)
1424 @patch("osm_ng_ro.ns.Ns._process_epa_params")
1425 def test__process_flavor_params_with_wrong_target_flavor(
1430 "no-target-flavor": "here",
1434 target_record_id
= ""
1436 with self
.assertRaises(KeyError):
1437 Ns
._process
_flavor
_params
(
1438 target_flavor
=target_flavor
,
1441 target_record_id
=target_record_id
,
1444 self
.assertFalse(epa_params
.called
)
1446 @patch("osm_ng_ro.ns.Ns._process_epa_params")
1447 def test__process_flavor_params_with_empty_indata(
1471 "memory-mb": "1024",
1476 target_record_id
= ""
1478 epa_params
.return_value
= {}
1480 result
= Ns
._process
_flavor
_params
(
1481 target_flavor
=target_flavor
,
1484 target_record_id
=target_record_id
,
1487 self
.assertTrue(epa_params
.called
)
1488 self
.assertDictEqual(result
, expected_result
)
1490 @patch("osm_ng_ro.ns.Ns._process_epa_params")
1491 def test__process_flavor_params_with_wrong_indata(
1515 "memory-mb": "1024",
1522 target_record_id
= ""
1524 epa_params
.return_value
= {}
1526 result
= Ns
._process
_flavor
_params
(
1527 target_flavor
=target_flavor
,
1530 target_record_id
=target_record_id
,
1533 self
.assertTrue(epa_params
.called
)
1534 self
.assertDictEqual(result
, expected_result
)
1536 @patch("osm_ng_ro.ns.Ns._process_epa_params")
1537 def test__process_flavor_params_with_ephemeral_disk(
1564 "memory-mb": "1024",
1572 "ns-flavor-id": "test_id",
1573 "virtual-storages": [
1575 "type-of-storage": "etsi-nfv-descriptors:ephemeral-storage",
1576 "size-of-storage": "10",
1585 target_record_id
= ""
1587 epa_params
.return_value
= {}
1589 result
= Ns
._process
_flavor
_params
(
1590 target_flavor
=target_flavor
,
1593 target_record_id
=target_record_id
,
1596 self
.assertTrue(epa_params
.called
)
1597 self
.assertDictEqual(result
, expected_result
)
1599 @patch("osm_ng_ro.ns.Ns._process_epa_params")
1600 def test__process_flavor_params_with_swap_disk(
1627 "memory-mb": "1024",
1635 "ns-flavor-id": "test_id",
1636 "virtual-storages": [
1638 "type-of-storage": "etsi-nfv-descriptors:swap-storage",
1639 "size-of-storage": "20",
1648 target_record_id
= ""
1650 epa_params
.return_value
= {}
1652 result
= Ns
._process
_flavor
_params
(
1653 target_flavor
=target_flavor
,
1656 target_record_id
=target_record_id
,
1659 self
.assertTrue(epa_params
.called
)
1660 self
.assertDictEqual(result
, expected_result
)
1662 @patch("osm_ng_ro.ns.Ns._process_epa_params")
1663 def test__process_flavor_params_with_epa_params(
1674 "numa": "there-is-numa-here",
1685 "numa": "there-is-numa-here",
1694 "memory-mb": "1024",
1699 target_record_id
= ""
1701 epa_params
.return_value
= {
1702 "numa": "there-is-numa-here",
1705 result
= Ns
._process
_flavor
_params
(
1706 target_flavor
=target_flavor
,
1709 target_record_id
=target_record_id
,
1712 self
.assertTrue(epa_params
.called
)
1713 self
.assertDictEqual(result
, expected_result
)
1715 @patch("osm_ng_ro.ns.Ns._process_epa_params")
1716 def test__process_flavor_params(
1729 "numa": "there-is-numa-here",
1742 "numa": "there-is-numa-here",
1751 "memory-mb": "1024",
1759 "ns-flavor-id": "test_id",
1760 "virtual-storages": [
1762 "type-of-storage": "etsi-nfv-descriptors:ephemeral-storage",
1763 "size-of-storage": "10",
1766 "type-of-storage": "etsi-nfv-descriptors:swap-storage",
1767 "size-of-storage": "20",
1776 target_record_id
= ""
1778 epa_params
.return_value
= {
1779 "numa": "there-is-numa-here",
1782 result
= Ns
._process
_flavor
_params
(
1783 target_flavor
=target_flavor
,
1786 target_record_id
=target_record_id
,
1789 self
.assertTrue(epa_params
.called
)
1790 self
.assertDictEqual(result
, expected_result
)
1792 def test__ip_profile_to_ro_with_none(self
):
1795 result
= Ns
._ip
_profile
_to
_ro
(
1796 ip_profile
=ip_profile
,
1799 self
.assertIsNone(result
)
1801 def test__ip_profile_to_ro_with_empty_profile(self
):
1804 result
= Ns
._ip
_profile
_to
_ro
(
1805 ip_profile
=ip_profile
,
1808 self
.assertIsNone(result
)
1810 def test__ip_profile_to_ro_with_wrong_profile(self
):
1812 "no-profile": "here",
1815 "ip_version": "IPv4",
1816 "subnet_address": None,
1817 "gateway_address": None,
1818 "dhcp_enabled": False,
1819 "dhcp_start_address": None,
1823 result
= Ns
._ip
_profile
_to
_ro
(
1824 ip_profile
=ip_profile
,
1827 self
.assertDictEqual(expected_result
, result
)
1829 def test__ip_profile_to_ro_with_ipv4_profile(self
):
1831 "ip-version": "ipv4",
1832 "subnet-address": "192.168.0.0/24",
1833 "gateway-address": "192.168.0.254",
1836 "start-address": "192.168.0.10",
1841 "ip_version": "IPv4",
1842 "subnet_address": "192.168.0.0/24",
1843 "gateway_address": "192.168.0.254",
1844 "dhcp_enabled": True,
1845 "dhcp_start_address": "192.168.0.10",
1849 result
= Ns
._ip
_profile
_to
_ro
(
1850 ip_profile
=ip_profile
,
1853 self
.assertDictEqual(expected_result
, result
)
1855 def test__ip_profile_to_ro_with_ipv6_profile(self
):
1857 "ip-version": "ipv6",
1858 "subnet-address": "2001:0200:0001::/48",
1859 "gateway-address": "2001:0200:0001:ffff:ffff:ffff:ffff:fffe",
1862 "start-address": "2001:0200:0001::0010",
1867 "ip_version": "IPv6",
1868 "subnet_address": "2001:0200:0001::/48",
1869 "gateway_address": "2001:0200:0001:ffff:ffff:ffff:ffff:fffe",
1870 "dhcp_enabled": True,
1871 "dhcp_start_address": "2001:0200:0001::0010",
1875 result
= Ns
._ip
_profile
_to
_ro
(
1876 ip_profile
=ip_profile
,
1879 self
.assertDictEqual(expected_result
, result
)
1881 def test__ip_profile_to_ro_with_dns_server(self
):
1883 "ip-version": "ipv4",
1884 "subnet-address": "192.168.0.0/24",
1885 "gateway-address": "192.168.0.254",
1888 "start-address": "192.168.0.10",
1893 "address": "8.8.8.8",
1896 "address": "1.1.1.1",
1899 "address": "1.0.0.1",
1904 "ip_version": "IPv4",
1905 "subnet_address": "192.168.0.0/24",
1906 "gateway_address": "192.168.0.254",
1907 "dhcp_enabled": True,
1908 "dhcp_start_address": "192.168.0.10",
1910 "dns_address": "8.8.8.8;1.1.1.1;1.0.0.1",
1913 result
= Ns
._ip
_profile
_to
_ro
(
1914 ip_profile
=ip_profile
,
1917 self
.assertDictEqual(expected_result
, result
)
1919 def test__ip_profile_to_ro_with_security_group(self
):
1921 "ip-version": "ipv4",
1922 "subnet-address": "192.168.0.0/24",
1923 "gateway-address": "192.168.0.254",
1926 "start-address": "192.168.0.10",
1930 "some-security-group": "here",
1934 "ip_version": "IPv4",
1935 "subnet_address": "192.168.0.0/24",
1936 "gateway_address": "192.168.0.254",
1937 "dhcp_enabled": True,
1938 "dhcp_start_address": "192.168.0.10",
1941 "some-security-group": "here",
1945 result
= Ns
._ip
_profile
_to
_ro
(
1946 ip_profile
=ip_profile
,
1949 self
.assertDictEqual(expected_result
, result
)
1951 def test__ip_profile_to_ro(self
):
1953 "ip-version": "ipv4",
1954 "subnet-address": "192.168.0.0/24",
1955 "gateway-address": "192.168.0.254",
1958 "start-address": "192.168.0.10",
1963 "address": "8.8.8.8",
1966 "address": "1.1.1.1",
1969 "address": "1.0.0.1",
1973 "some-security-group": "here",
1977 "ip_version": "IPv4",
1978 "subnet_address": "192.168.0.0/24",
1979 "gateway_address": "192.168.0.254",
1980 "dhcp_enabled": True,
1981 "dhcp_start_address": "192.168.0.10",
1983 "dns_address": "8.8.8.8;1.1.1.1;1.0.0.1",
1985 "some-security-group": "here",
1989 result
= Ns
._ip
_profile
_to
_ro
(
1990 ip_profile
=ip_profile
,
1993 self
.assertDictEqual(expected_result
, result
)
1995 @patch("osm_ng_ro.ns.Ns._ip_profile_to_ro")
1996 def test__process_net_params_with_empty_params(
2007 "provider_network": "some-profile-here",
2009 target_record_id
= ""
2012 "net_name": "ns-name-vld-name",
2013 "net_type": "bridge",
2015 "some_ip_profile": "here",
2017 "provider_network_profile": "some-profile-here",
2021 ip_profile_to_ro
.return_value
= {
2022 "some_ip_profile": "here",
2025 result
= Ns
._process
_net
_params
(
2026 target_vld
=target_vld
,
2029 target_record_id
=target_record_id
,
2032 self
.assertDictEqual(expected_result
, result
)
2033 self
.assertTrue(ip_profile_to_ro
.called
)
2035 @patch("osm_ng_ro.ns.Ns._ip_profile_to_ro")
2036 def test__process_net_params_with_vim_info_sdn(
2048 "sdn-ports": ["some", "ports", "here"],
2049 "vlds": ["some", "vlds", "here"],
2052 target_record_id
= "vld.sdn.something"
2055 "sdn-ports": ["some", "ports", "here"],
2056 "vlds": ["some", "vlds", "here"],
2061 result
= Ns
._process
_net
_params
(
2062 target_vld
=target_vld
,
2065 target_record_id
=target_record_id
,
2068 self
.assertDictEqual(expected_result
, result
)
2069 self
.assertFalse(ip_profile_to_ro
.called
)
2071 @patch("osm_ng_ro.ns.Ns._ip_profile_to_ro")
2072 def test__process_net_params_with_vim_info_sdn_target_vim(
2084 "sdn-ports": ["some", "ports", "here"],
2085 "vlds": ["some", "vlds", "here"],
2086 "target_vim": "some-vim",
2089 target_record_id
= "vld.sdn.something"
2091 "depends_on": ["some-vim vld.sdn"],
2093 "sdn-ports": ["some", "ports", "here"],
2094 "vlds": ["some", "vlds", "here"],
2095 "target_vim": "some-vim",
2100 result
= Ns
._process
_net
_params
(
2101 target_vld
=target_vld
,
2104 target_record_id
=target_record_id
,
2107 self
.assertDictEqual(expected_result
, result
)
2108 self
.assertFalse(ip_profile_to_ro
.called
)
2110 @patch("osm_ng_ro.ns.Ns._ip_profile_to_ro")
2111 def test__process_net_params_with_vim_network_name(
2122 "vim_network_name": "some-network-name",
2124 target_record_id
= "vld.sdn.something"
2128 "name": "some-network-name",
2133 result
= Ns
._process
_net
_params
(
2134 target_vld
=target_vld
,
2137 target_record_id
=target_record_id
,
2140 self
.assertDictEqual(expected_result
, result
)
2141 self
.assertFalse(ip_profile_to_ro
.called
)
2143 @patch("osm_ng_ro.ns.Ns._ip_profile_to_ro")
2144 def test__process_net_params_with_vim_network_id(
2155 "vim_network_id": "some-network-id",
2157 target_record_id
= "vld.sdn.something"
2161 "id": "some-network-id",
2166 result
= Ns
._process
_net
_params
(
2167 target_vld
=target_vld
,
2170 target_record_id
=target_record_id
,
2173 self
.assertDictEqual(expected_result
, result
)
2174 self
.assertFalse(ip_profile_to_ro
.called
)
2176 @patch("osm_ng_ro.ns.Ns._ip_profile_to_ro")
2177 def test__process_net_params_with_mgmt_network(
2184 "mgmt-network": "some-mgmt-network",
2190 target_record_id
= "vld.sdn.something"
2198 result
= Ns
._process
_net
_params
(
2199 target_vld
=target_vld
,
2202 target_record_id
=target_record_id
,
2205 self
.assertDictEqual(expected_result
, result
)
2206 self
.assertFalse(ip_profile_to_ro
.called
)
2208 @patch("osm_ng_ro.ns.Ns._ip_profile_to_ro")
2209 def test__process_net_params_with_underlay_eline(
2215 "underlay": "some-underlay-here",
2222 "provider_network": "some-profile-here",
2224 target_record_id
= ""
2228 "some_ip_profile": "here",
2230 "net_name": "ns-name-vld-name",
2232 "provider_network_profile": "some-profile-here",
2236 ip_profile_to_ro
.return_value
= {
2237 "some_ip_profile": "here",
2240 result
= Ns
._process
_net
_params
(
2241 target_vld
=target_vld
,
2244 target_record_id
=target_record_id
,
2247 self
.assertDictEqual(expected_result
, result
)
2248 self
.assertTrue(ip_profile_to_ro
.called
)
2250 @patch("osm_ng_ro.ns.Ns._ip_profile_to_ro")
2251 def test__process_net_params_with_underlay_elan(
2257 "underlay": "some-underlay-here",
2264 "provider_network": "some-profile-here",
2266 target_record_id
= ""
2270 "some_ip_profile": "here",
2272 "net_name": "ns-name-vld-name",
2274 "provider_network_profile": "some-profile-here",
2278 ip_profile_to_ro
.return_value
= {
2279 "some_ip_profile": "here",
2282 result
= Ns
._process
_net
_params
(
2283 target_vld
=target_vld
,
2286 target_record_id
=target_record_id
,
2289 self
.assertDictEqual(expected_result
, result
)
2290 self
.assertTrue(ip_profile_to_ro
.called
)